

from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

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


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFFunnelBaseModel,
					    TFFunnelForMaskedLM,
					    TFFunnelForMultipleChoice,
					    TFFunnelForPreTraining,
					    TFFunnelForQuestionAnswering,
					    TFFunnelForSequenceClassification,
					    TFFunnelForTokenClassification,
					    TFFunnelModel,
					)







class 					lowercase							:




				def __init__(   self ,  snake_case ,  snake_case=13 ,  snake_case=7 ,  snake_case=True ,  snake_case=True ,  snake_case=True ,  snake_case=True ,  snake_case=99 ,  snake_case=[1, 1, 2] ,  snake_case=1 ,  snake_case=32 ,  snake_case=4 ,  snake_case=8 ,  snake_case=37 ,  snake_case="gelu_new" ,  snake_case=0.1 ,  snake_case=0.1 ,  snake_case=0.0 ,  snake_case=512 ,  snake_case=3 ,  snake_case=0.02 ,  snake_case=3 ,  snake_case=4 ,  snake_case=None ,  snake_case=False ,  ):
											snake_case_     							=       parent
											snake_case_     							=       batch_size
											snake_case_     							=       seq_length
											snake_case_     							=       is_training
											snake_case_     							=       use_input_mask
											snake_case_     							=       use_token_type_ids
											snake_case_     							=       use_labels
											snake_case_     							=       vocab_size
											snake_case_     							=       block_sizes
											snake_case_     							=       num_decoder_layers
											snake_case_     							=       d_model
											snake_case_     							=       n_head
											snake_case_     							=       d_head
											snake_case_     							=       d_inner
											snake_case_     							=       hidden_act
											snake_case_     							=       hidden_dropout
											snake_case_     							=       attention_dropout
											snake_case_     							=       activation_dropout
											snake_case_     							=       max_position_embeddings
											snake_case_     							=       type_vocab_size
											snake_case_     							=       2
											snake_case_     							=       num_labels
											snake_case_     							=       num_choices
											snake_case_     							=       scope
											snake_case_     							=       initializer_std

											# Used in the tests to check the size of the first attention layer
											snake_case_     							=       n_head
											# Used in the tests to check the size of the first hidden state
											snake_case_     							=       self.d_model
											# Used in the tests to check the number of output hidden states/attentions
											snake_case_     							=       sum(self.block_sizes			) + (0 if base else self.num_decoder_layers)
											# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
											# the last hidden state of the first block (which is the first hidden state of the decoder).
											if not base:
																		snake_case_     							=       self.num_hidden_layers + 2




				def        a				(   self			):
											snake_case_     							=       ids_tensor([self.batch_size, self.seq_length] ,  self.vocab_size			)

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

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

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

											snake_case_     							=       FunnelConfig(
											    vocab_size=self.vocab_size ,  block_sizes=self.block_sizes ,  num_decoder_layers=self.num_decoder_layers ,  d_model=self.d_model ,  n_head=self.n_head ,  d_head=self.d_head ,  d_inner=self.d_inner ,  hidden_act=self.hidden_act ,  hidden_dropout=self.hidden_dropout ,  attention_dropout=self.attention_dropout ,  activation_dropout=self.activation_dropout ,  max_position_embeddings=self.max_position_embeddings ,  type_vocab_size=self.type_vocab_size ,  initializer_std=self.initializer_std ,  )

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




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       TFFunnelModel(config=snake_case			)
											snake_case_     							=       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											snake_case_     							=       model(snake_case			)

											snake_case_     							=       [input_ids, input_mask]
											snake_case_     							=       model(snake_case			)

											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.d_model)			)

											snake_case_     							=       False
											snake_case_     							=       TFFunnelModel(config=snake_case			)
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.d_model)			)

											snake_case_     							=       False
											snake_case_     							=       TFFunnelModel(config=snake_case			)
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.d_model)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       TFFunnelBaseModel(config=snake_case			)
											snake_case_     							=       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											snake_case_     							=       model(snake_case			)

											snake_case_     							=       [input_ids, input_mask]
											snake_case_     							=       model(snake_case			)

											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, 2, self.d_model)			)

											snake_case_     							=       False
											snake_case_     							=       TFFunnelBaseModel(config=snake_case			)
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, 3, self.d_model)			)

											snake_case_     							=       False
											snake_case_     							=       TFFunnelBaseModel(config=snake_case			)
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, 2, self.d_model)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       TFFunnelForPreTraining(config=snake_case			)
											snake_case_     							=       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       TFFunnelForMaskedLM(config=snake_case			)
											snake_case_     							=       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length, self.vocab_size)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       self.num_labels
											snake_case_     							=       TFFunnelForSequenceClassification(config=snake_case			)
											snake_case_     							=       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       self.num_choices
											snake_case_     							=       TFFunnelForMultipleChoice(config=snake_case			)
											snake_case_     							=       tf.tile(tf.expand_dims(snake_case ,  1			) ,  (1, self.num_choices, 1)			)
											snake_case_     							=       tf.tile(tf.expand_dims(snake_case ,  1			) ,  (1, self.num_choices, 1)			)
											snake_case_     							=       tf.tile(tf.expand_dims(snake_case ,  1			) ,  (1, self.num_choices, 1)			)
											snake_case_     							=       {
											    'input_ids': multiple_choice_inputs_ids,
											    'attention_mask': multiple_choice_input_mask,
											    'token_type_ids': multiple_choice_token_type_ids,
											}
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_choices)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       self.num_labels
											snake_case_     							=       TFFunnelForTokenClassification(config=snake_case			)
											snake_case_     							=       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											snake_case_     							=       model(snake_case			)
											self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length, self.num_labels)			)




				def        a				(   self ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  snake_case ,  ):
											snake_case_     							=       TFFunnelForQuestionAnswering(config=snake_case			)
											snake_case_     							=       {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
											snake_case_     							=       model(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        a				(   self			):
											snake_case_     							=       self.prepare_config_and_inputs()
											(
											    (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       (
											    snake_case_
											)							,       
											)     							=       config_and_inputs
											snake_case_     							=       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
											return config, inputs_dict







@require_tf
class 					lowercase							(			lowercase_      ,    lowercase_      ,    unittest.TestCase     ):
				__SCREAMING_SNAKE_CASE   :					Any			     =     (
				    (
				        TFFunnelModel,
				        TFFunnelForMaskedLM,
				        TFFunnelForPreTraining,
				        TFFunnelForQuestionAnswering,
				        TFFunnelForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				__SCREAMING_SNAKE_CASE   :					Dict			     =     (
				    {
				        '''feature-extraction''': (TFFunnelBaseModel, TFFunnelModel),
				        '''fill-mask''': TFFunnelForMaskedLM,
				        '''question-answering''': TFFunnelForQuestionAnswering,
				        '''text-classification''': TFFunnelForSequenceClassification,
				        '''token-classification''': TFFunnelForTokenClassification,
				        '''zero-shot''': TFFunnelForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				__SCREAMING_SNAKE_CASE   :					str			     =     False
				__SCREAMING_SNAKE_CASE   :					str			     =     False




				def        a				(   self			):
											snake_case_     							=       TFFunnelModelTester(self			)
											snake_case_     							=       ConfigTester(self ,  config_class=snake_case			)




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




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_pretraining(*snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_lm(*snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*snake_case			)







@require_tf
class 					lowercase							(			lowercase_      ,    unittest.TestCase     ):
				__SCREAMING_SNAKE_CASE   :					str			     =     (
				    (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
				)
				__SCREAMING_SNAKE_CASE   :					Optional[Any]			     =     False
				__SCREAMING_SNAKE_CASE   :					Union[str, Any]			     =     False




				def        a				(   self			):
											snake_case_     							=       TFFunnelModelTester(self ,  base=snake_case			)
											snake_case_     							=       ConfigTester(self ,  config_class=snake_case			)




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




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_base_model(*snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*snake_case			)




				def        a				(   self			):
											snake_case_     							=       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_multiple_choice(*snake_case			)







import argparse
import struct
import unittest







class 					lowercase							:




				def __init__(   self ,  snake_case			):
											snake_case_     							=       data

											# Initialize hash values
											snake_case_     							=       [
											    0x6A09E667,
											    0xBB67AE85,
											    0x3C6EF372,
											    0xA54FF53A,
											    0x510E527F,
											    0x9B05688C,
											    0x1F83D9AB,
											    0x5BE0CD19,
											]

											# Initialize round constants
											snake_case_     							=       [
											    0x428A2F98,
											    0x71374491,
											    0xB5C0FBCF,
											    0xE9B5DBA5,
											    0x3956C25B,
											    0x59F111F1,
											    0x923F82A4,
											    0xAB1C5ED5,
											    0xD807AA98,
											    0x12835B01,
											    0x243185BE,
											    0x550C7DC3,
											    0x72BE5D74,
											    0x80DEB1FE,
											    0x9BDC06A7,
											    0xC19BF174,
											    0xE49B69C1,
											    0xEFBE4786,
											    0x0FC19DC6,
											    0x240CA1CC,
											    0x2DE92C6F,
											    0x4A7484AA,
											    0x5CB0A9DC,
											    0x76F988DA,
											    0x983E5152,
											    0xA831C66D,
											    0xB00327C8,
											    0xBF597FC7,
											    0xC6E00BF3,
											    0xD5A79147,
											    0x06CA6351,
											    0x14292967,
											    0x27B70A85,
											    0x2E1B2138,
											    0x4D2C6DFC,
											    0x53380D13,
											    0x650A7354,
											    0x766A0ABB,
											    0x81C2C92E,
											    0x92722C85,
											    0xA2BFE8A1,
											    0xA81A664B,
											    0xC24B8B70,
											    0xC76C51A3,
											    0xD192E819,
											    0xD6990624,
											    0xF40E3585,
											    0x106AA070,
											    0x19A4C116,
											    0x1E376C08,
											    0x2748774C,
											    0x34B0BCB5,
											    0x391C0CB3,
											    0x4ED8AA4A,
											    0x5B9CCA4F,
											    0x682E6FF3,
											    0x748F82EE,
											    0x78A5636F,
											    0x84C87814,
											    0x8CC70208,
											    0x90BEFFFA,
											    0xA4506CEB,
											    0xBEF9A3F7,
											    0xC67178F2,
											]

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




				@staticmethod
				def        a				(   snake_case			):
											snake_case_     							=       b'\x80' + (b'\x00' * (63 - (len(snake_case			) + 8) % 64))
											snake_case_     							=       struct.pack('>Q' ,  (len(snake_case			) * 8)			)
											return data + padding + big_endian_integer




				def        a				(   self			):
											# Convert into blocks of 64 bytes
											snake_case_     							=       [
											    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
																		snake_case_     							=       list(struct.unpack('>16L' ,  snake_case			)			)
																		# add 48 0-ed integers
																		words += [0] * 48

																		snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_     							=       self.hashes

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

																																snake_case_     							=       (
																																    words[index - 16] + sa + words[index - 7] + sa
																																) % 0x100000000

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

																									snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_							,       snake_case_     							=       (
																									    g,
																									    f,
																									    e,
																									    ((d + tempa) % 0x100000000),
																									    c,
																									    b,
																									    a,
																									    ((tempa + tempa) % 0x100000000),
																									)

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

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

											snake_case_     							=       ''.join([hex(snake_case			)[2:].zfill(8			) for value in self.hashes]			)




				def        a				(   self ,  snake_case ,  snake_case			):
											return 0xFFFFFFFF & (value << (32 - rotations)) | (value >> rotations)







class 					lowercase							(			unittest.TestCase     ):




				def        a				(   self			):
											import hashlib

											snake_case_     							=       bytes('Test String' ,  'utf-8'			)
											self.assertEqual(SHAaaa(snake_case			).hash ,  hashlib.shaaaa(snake_case			).hexdigest()			)





def    __lowerCamelCase      (					):







							'''simple docstring'''






							import doctest

							doctest.testmod()

							snake_case_     							=       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' )

							snake_case_     							=       parser.parse_args()

							snake_case_     							=       args.input_string

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

							print(SHAaaa(UpperCamelCase__ ).hash )


if __name__ == "__main__":
					main()




