






'''simple docstring'''







import json
import os
import subprocess
import unittest
from ast import literal_eval

import pytest
from parameterized import parameterized, parameterized_class

from . import is_sagemaker_available


if is_sagemaker_available():
							from sagemaker import Session, TrainingJobAnalytics
							from sagemaker.huggingface import HuggingFace




@pytest.mark.skipif(
    literal_eval(os.getenv('TEST_SAGEMAKER'   ,'False'			)			) is not True   ,reason='Skipping test because should only be run when releasing minor transformers version'   ,)
@pytest.mark.usefixtures('sm_env'			)
@parameterized_class(
    [
        {
            'framework': 'pytorch',
            'script': 'run_glue_model_parallelism.py',
            'model_name_or_path': 'roberta-large',
            'instance_type': 'ml.p3dn.24xlarge',
            'results': {'train_runtime': 1600, 'eval_accuracy': 0.3, 'eval_loss': 1.2},
        },
        {
            'framework': 'pytorch',
            'script': 'run_glue.py',
            'model_name_or_path': 'roberta-large',
            'instance_type': 'ml.p3dn.24xlarge',
            'results': {'train_runtime': 1600, 'eval_accuracy': 0.3, 'eval_loss': 1.2},
        },
    ]			)
class 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self       ):
								if self.framework == "pytorch":
														subprocess.run(
														    F'''cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py'''.split()   ,encoding="""utf-8"""   ,check=_lowerCAmelCase   ,)
								assert hasattr(self   ,"""env"""       )






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase       ):
								# configuration for running training on smdistributed Model Parallel
								lowerCamelCase__         =  {
								    """enabled""": True,
								    """processes_per_host""": 8,
								}
								lowerCamelCase__         =  {
								    """enabled""": True,
								    """parameters""": {
								        """microbatches""": 4,
								        """placement_strategy""": """spread""",
								        """pipeline""": """interleaved""",
								        """optimize""": """speed""",
								        """partitions""": 4,
								        """ddp""": True,
								    },
								}

								lowerCamelCase__         =  {"""smdistributed""": {"""modelparallel""": smp_options}, """mpi""": mpi_options}

								lowerCamelCase__         =  """trainer""" if self.script == """run_glue.py""" else """smtrainer"""
								# creates estimator
								return HuggingFace(
								    entry_point=self.script   ,source_dir=self.env.test_path   ,role=self.env.role   ,image_uri=self.env.image_uri   ,base_job_name=F'''{self.env.base_job_name}-{instance_count}-smp-{name_extension}'''   ,instance_count=_lowerCAmelCase   ,instance_type=self.instance_type   ,debugger_hook_config=_lowerCAmelCase   ,hyperparameters={
								        **self.env.hyperparameters,
								        """model_name_or_path""": self.model_name_or_path,
								        """max_steps""": 5_00,
								    }   ,metric_definitions=self.env.metric_definitions   ,distribution=_lowerCAmelCase   ,py_version="""py36"""   ,)






		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase       ):
								TrainingJobAnalytics(_lowerCAmelCase       ).export_csv(F'''{self.env.test_path}/{job_name}_metrics.csv'''       )






		@parameterized.expand([(1,)]       )
		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase       ):
								# create estimator
								lowerCamelCase__         =  self.create_estimator(_lowerCAmelCase       )

								# run training
								estimator.fit()

								# result dataframe
								lowerCamelCase__         =  TrainingJobAnalytics(estimator.latest_training_job.name       ).dataframe()

								# extract kpis
								lowerCamelCase__         =  list(result_metrics_df[result_metrics_df.metric_name == """eval_accuracy"""]["""value"""]       )
								lowerCamelCase__         =  list(result_metrics_df[result_metrics_df.metric_name == """eval_loss"""]["""value"""]       )
								# get train time from SageMaker job, this includes starting, preprocessing, stopping
								lowerCamelCase__         =  (
								    Session().describe_training_job(estimator.latest_training_job.name       ).get("""TrainingTimeInSeconds"""   ,99_99_99       )
								)

								# assert kpis
								assert train_runtime <= self.results["train_runtime"]
								assert all(t >= self.results["""eval_accuracy"""] for t in eval_accuracy       )
								assert all(t <= self.results["""eval_loss"""] for t in eval_loss       )

								# dump tests result into json file to share in PR
								with open(F'''{estimator.latest_training_job.name}.json'''   ,"""w"""       ) as outfile:
														json.dump({"""train_time""": train_runtime, """eval_accuracy""": eval_accuracy, """eval_loss""": eval_loss}   ,_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()

