


"""simple docstring"""

import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY







@is_pipeline_test
class    __lowercase     (					unittest.TestCase):







						"""simple docstring"""







						_A		:							int							       =		MODEL_FOR_MASKED_LM_MAPPING
						_A		:							Dict							       =		TF_MODEL_FOR_MASKED_LM_MAPPING







						def 						__UpperCamelCase							(self       ):
											super().tearDown()
											# clean-up as much as possible GPU memory occupied by PyTorch
											gc.collect()
											if is_torch_available():
																import torch

																torch.cuda.empty_cache()







						@require_tf
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		int 					=					pipeline(task="""fill-mask"""   ,		model="""sshleifer/tiny-distilroberta-base"""   ,		top_k=2   ,		framework="""tf"""       )
											snake_case_					:		Dict 					=					unmasker("""My name is <mask>"""       )
											self.assertEqual(
											    nested_simplify(lowercase__   ,		decimals=6       )   ,		[
											        {"""sequence""": """My name is grouped""", """score""": 2.1e-05, """token""": 3_80_15, """token_str""": """ grouped"""},
											        {"""sequence""": """My name is accuser""", """score""": 2.1e-05, """token""": 2_55_06, """token_str""": """ accuser"""},
											    ]   ,		)

											snake_case_					:		Any 					=					unmasker("""The largest city in France is <mask>"""       )
											self.assertEqual(
											    nested_simplify(lowercase__   ,		decimals=6       )   ,		[
											        {
											            """sequence""": """The largest city in France is grouped""",
											            """score""": 2.1e-05,
											            """token""": 3_80_15,
											            """token_str""": """ grouped""",
											        },
											        {
											            """sequence""": """The largest city in France is accuser""",
											            """score""": 2.1e-05,
											            """token""": 2_55_06,
											            """token_str""": """ accuser""",
											        },
											    ]   ,		)

											snake_case_					:		List[Any] 					=					unmasker("""My name is <mask>"""   ,		targets=[""" Patrick""", """ Clara""", """ Teven"""]   ,		top_k=3       )
											self.assertEqual(
											    nested_simplify(lowercase__   ,		decimals=6       )   ,		[
											        {"""sequence""": """My name is Clara""", """score""": 2e-05, """token""": 1_36_06, """token_str""": """ Clara"""},
											        {"""sequence""": """My name is Patrick""", """score""": 2e-05, """token""": 34_99, """token_str""": """ Patrick"""},
											        {"""sequence""": """My name is Te""", """score""": 1.9e-05, """token""": 29_41, """token_str""": """ Te"""},
											    ]   ,		)







						@require_torch
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		int 					=					pipeline(task="""fill-mask"""   ,		model="""sshleifer/tiny-distilroberta-base"""   ,		top_k=2   ,		framework="""pt"""       )

											snake_case_					:		str 					=					unmasker("""My name is <mask>"""       )
											self.assertEqual(
											    nested_simplify(lowercase__   ,		decimals=6       )   ,		[
											        {"""sequence""": """My name is Maul""", """score""": 2.2e-05, """token""": 3_56_76, """token_str""": """ Maul"""},
											        {"""sequence""": """My name isELS""", """score""": 2.2e-05, """token""": 1_64_16, """token_str""": """ELS"""},
											    ]   ,		)

											snake_case_					:		str 					=					unmasker("""The largest city in France is <mask>"""       )
											self.assertEqual(
											    nested_simplify(lowercase__   ,		decimals=6       )   ,		[
											        {
											            """sequence""": """The largest city in France is Maul""",
											            """score""": 2.2e-05,
											            """token""": 3_56_76,
											            """token_str""": """ Maul""",
											        },
											        {"""sequence""": """The largest city in France isELS""", """score""": 2.2e-05, """token""": 1_64_16, """token_str""": """ELS"""},
											    ]   ,		)

											snake_case_					:		Any 					=					unmasker("""My name is <mask>"""   ,		targets=[""" Patrick""", """ Clara""", """ Teven"""]   ,		top_k=3       )
											self.assertEqual(
											    nested_simplify(lowercase__   ,		decimals=6       )   ,		[
											        {"""sequence""": """My name is Patrick""", """score""": 2.1e-05, """token""": 34_99, """token_str""": """ Patrick"""},
											        {"""sequence""": """My name is Te""", """score""": 2e-05, """token""": 29_41, """token_str""": """ Te"""},
											        {"""sequence""": """My name is Clara""", """score""": 2e-05, """token""": 1_36_06, """token_str""": """ Clara"""},
											    ]   ,		)

											snake_case_					:		str 					=					unmasker("""My name is <mask> <mask>"""   ,		top_k=2       )

											self.assertEqual(
											    nested_simplify(lowercase__   ,		decimals=6       )   ,		[
											        [
											            {
											                """score""": 2.2e-05,
											                """token""": 3_56_76,
											                """token_str""": """ Maul""",
											                """sequence""": """<s>My name is Maul<mask></s>""",
											            },
											            {"""score""": 2.2e-05, """token""": 1_64_16, """token_str""": """ELS""", """sequence""": """<s>My name isELS<mask></s>"""},
											        ],
											        [
											            {
											                """score""": 2.2e-05,
											                """token""": 3_56_76,
											                """token_str""": """ Maul""",
											                """sequence""": """<s>My name is<mask> Maul</s>""",
											            },
											            {"""score""": 2.2e-05, """token""": 1_64_16, """token_str""": """ELS""", """sequence""": """<s>My name is<mask>ELS</s>"""},
											        ],
											    ]   ,		)







						@require_torch_gpu
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[Any] 					=					pipeline("""fill-mask"""   ,		model="""hf-internal-testing/tiny-random-distilbert"""   ,		device=0   ,		framework="""pt"""       )

											# convert model to fp16
											pipe.model.half()

											snake_case_					:		Any 					=					pipe("""Paris is the [MASK] of France."""       )
											# We actually don't care about the result, we just want to make sure
											# it works, meaning the float16 tensor got casted back to float32
											# for postprocessing.
											self.assertIsInstance(lowercase__   ,		lowercase__       )







						@slow
						@require_torch
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Tuple 					=					pipeline(task="""fill-mask"""   ,		model="""distilroberta-base"""   ,		top_k=2   ,		framework="""pt"""       )
											self.run_large_test(lowercase__       )







						@slow
						@require_tf
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[Any] 					=					pipeline(task="""fill-mask"""   ,		model="""distilroberta-base"""   ,		top_k=2   ,		framework="""tf"""       )
											self.run_large_test(lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__       ):
											snake_case_					:		Dict 					=					unmasker("""My name is <mask>"""       )
											self.assertEqual(
											    nested_simplify(lowercase__       )   ,		[
											        {"""sequence""": """My name is John""", """score""": 0.008, """token""": 6_10, """token_str""": """ John"""},
											        {"""sequence""": """My name is Chris""", """score""": 0.007, """token""": 15_73, """token_str""": """ Chris"""},
											    ]   ,		)
											snake_case_					:		Optional[int] 					=					unmasker("""The largest city in France is <mask>"""       )
											self.assertEqual(
											    nested_simplify(lowercase__       )   ,		[
											        {
											            """sequence""": """The largest city in France is Paris""",
											            """score""": 0.251,
											            """token""": 22_01,
											            """token_str""": """ Paris""",
											        },
											        {
											            """sequence""": """The largest city in France is Lyon""",
											            """score""": 0.214,
											            """token""": 1_27_90,
											            """token_str""": """ Lyon""",
											        },
											    ]   ,		)

											snake_case_					:		Dict 					=					unmasker("""My name is <mask>"""   ,		targets=[""" Patrick""", """ Clara""", """ Teven"""]   ,		top_k=3       )
											self.assertEqual(
											    nested_simplify(lowercase__       )   ,		[
											        {"""sequence""": """My name is Patrick""", """score""": 0.005, """token""": 34_99, """token_str""": """ Patrick"""},
											        {"""sequence""": """My name is Clara""", """score""": 0.000, """token""": 1_36_06, """token_str""": """ Clara"""},
											        {"""sequence""": """My name is Te""", """score""": 0.000, """token""": 29_41, """token_str""": """ Te"""},
											    ]   ,		)







						@require_torch
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Tuple 					=					pipeline(task="""fill-mask"""   ,		model="""sshleifer/tiny-distilroberta-base"""   ,		framework="""pt"""       )
											snake_case_					:		Optional[Any] 					=					None
											snake_case_					:		Optional[Any] 					=					None
											self.run_pipeline_test(lowercase__   ,		[]       )







						@require_tf
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[str] 					=					pipeline(task="""fill-mask"""   ,		model="""sshleifer/tiny-distilroberta-base"""   ,		framework="""tf"""       )
											snake_case_					:		str 					=					None
											snake_case_					:		str 					=					None
											self.run_pipeline_test(lowercase__   ,		[]       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__   ,		lowercase__       ):
											if tokenizer is None or tokenizer.mask_token_id is None:
																self.skipTest("""The provided tokenizer has no mask token, (probably reformer or wav2vec2)"""       )

											snake_case_					:		Dict 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__       )
											snake_case_					:		Tuple 					=					[
											    f'This is another {tokenizer.mask_token} test',
											]
											return fill_masker, examples







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											snake_case_					:		Optional[int] 					=					fill_masker.tokenizer
											snake_case_					:		Optional[int] 					=					fill_masker.model

											snake_case_					:		Any 					=					fill_masker(
											    f'This is a {tokenizer.mask_token}'   ,		)
											self.assertEqual(
											    lowercase__   ,		[
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											    ]   ,		)

											snake_case_					:		Union[str, Any] 					=					fill_masker([f'This is a {tokenizer.mask_token}']       )
											self.assertEqual(
											    lowercase__   ,		[
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											    ]   ,		)

											snake_case_					:		List[Any] 					=					fill_masker([f'This is a {tokenizer.mask_token}', f'Another {tokenizer.mask_token} great test.']       )
											self.assertEqual(
											    lowercase__   ,		[
											        [
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        ],
											        [
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        ],
											    ]   ,		)

											with self.assertRaises(lowercase__       ):
																fill_masker([None]       )
											# No mask_token is not supported
											with self.assertRaises(lowercase__       ):
																fill_masker("""This is"""       )

											self.run_test_top_k(lowercase__   ,		lowercase__       )
											self.run_test_targets(lowercase__   ,		lowercase__       )
											self.run_test_top_k_targets(lowercase__   ,		lowercase__       )
											self.fill_mask_with_duplicate_targets_and_top_k(lowercase__   ,		lowercase__       )
											self.fill_mask_with_multiple_masks(lowercase__   ,		lowercase__       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											snake_case_					:		Tuple 					=					tokenizer.get_vocab()
											snake_case_					:		Tuple 					=					sorted(vocab.keys()       )[:2]
											# Pipeline argument
											snake_case_					:		Union[str, Any] 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__   ,		targets=lowercase__       )
											snake_case_					:		Any 					=					fill_masker(f'This is a {tokenizer.mask_token}'       )
											self.assertEqual(
											    lowercase__   ,		[
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											    ]   ,		)
											snake_case_					:		str 					=					{vocab[el] for el in targets}
											self.assertEqual({el["""token"""] for el in outputs}   ,		lowercase__       )
											snake_case_					:		Union[str, Any] 					=					[tokenizer.decode([x]       ) for x in target_ids]
											self.assertEqual({el["""token_str"""] for el in outputs}   ,		set(lowercase__       )       )

											# Call argument
											snake_case_					:		Optional[Any] 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__       )
											snake_case_					:		List[str] 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		targets=lowercase__       )
											self.assertEqual(
											    lowercase__   ,		[
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											    ]   ,		)
											snake_case_					:		Tuple 					=					{vocab[el] for el in targets}
											self.assertEqual({el["""token"""] for el in outputs}   ,		lowercase__       )
											snake_case_					:		Dict 					=					[tokenizer.decode([x]       ) for x in target_ids]
											self.assertEqual({el["""token_str"""] for el in outputs}   ,		set(lowercase__       )       )

											# Score equivalence
											snake_case_					:		List[Any] 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		targets=lowercase__       )
											snake_case_					:		List[Any] 					=					[top_mask["""token_str"""] for top_mask in outputs]
											snake_case_					:		Dict 					=					[top_mask["""score"""] for top_mask in outputs]

											# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
											if set(lowercase__       ) == set(lowercase__       ):
																snake_case_					:		Optional[Any] 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		targets=lowercase__       )
																snake_case_					:		Tuple 					=					[top_mask["""score"""] for top_mask in unmasked_targets]
																self.assertEqual(nested_simplify(lowercase__       )   ,		nested_simplify(lowercase__       )       )

											# Raises with invalid
											with self.assertRaises(lowercase__       ):
																snake_case_					:		Optional[Any] 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		targets=[]       )
											# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
											if "" not in tokenizer.get_vocab():
																with self.assertRaises(lowercase__       ):
																					snake_case_					:		Union[str, Any] 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		targets=[""""""]       )
																with self.assertRaises(lowercase__       ):
																					snake_case_					:		str 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		targets=""""""       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											snake_case_					:		List[str] 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__   ,		top_k=2       )
											snake_case_					:		Optional[Any] 					=					fill_masker(f'This is a {tokenizer.mask_token}'       )
											self.assertEqual(
											    lowercase__   ,		[
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											    ]   ,		)

											snake_case_					:		Optional[Any] 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__       )
											snake_case_					:		Dict 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		top_k=2       )
											self.assertEqual(
											    lowercase__   ,		[
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											    ]   ,		)
											self.assertEqual(nested_simplify(lowercase__       )   ,		nested_simplify(lowercase__       )       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											snake_case_					:		List[str] 					=					tokenizer.get_vocab()
											snake_case_					:		int 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__       )

											# top_k=2, ntargets=3
											snake_case_					:		Optional[int] 					=					sorted(vocab.keys()       )[:3]
											snake_case_					:		Dict 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		top_k=2   ,		targets=lowercase__       )

											# If we use the most probably targets, and filter differently, we should still
											# have the same results
											snake_case_					:		Any 					=					[el["""token_str"""] for el in sorted(lowercase__   ,		key=lambda lowercase__       : x["score"]   ,		reverse=lowercase__       )]
											# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
											if set(lowercase__       ).issubset(lowercase__       ):
																snake_case_					:		Any 					=					fill_masker(f'This is a {tokenizer.mask_token}'   ,		top_k=3   ,		targets=lowercase__       )
																# They should yield exactly the same result
																self.assertEqual(nested_simplify(lowercase__       )   ,		nested_simplify(lowercase__       )       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											snake_case_					:		List[str] 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__       )
											snake_case_					:		Optional[Any] 					=					tokenizer.get_vocab()
											# String duplicates + id duplicates
											snake_case_					:		str 					=					sorted(vocab.keys()       )[:3]
											snake_case_					:		int 					=					[targets[0], targets[1], targets[0], targets[2], targets[1]]
											snake_case_					:		Any 					=					fill_masker(f'My name is {tokenizer.mask_token}'   ,		targets=lowercase__   ,		top_k=10       )

											# The target list contains duplicates, so we can't output more
											# than them
											self.assertEqual(len(lowercase__       )   ,		3       )







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__       ):
											snake_case_					:		List[Any] 					=					FillMaskPipeline(model=lowercase__   ,		tokenizer=lowercase__       )

											snake_case_					:		List[str] 					=					fill_masker(
											    f'This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'   ,		top_k=2       )
											self.assertEqual(
											    lowercase__   ,		[
											        [
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        ],
											        [
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        ],
											        [
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											            {"""sequence""": ANY(lowercase__       ), """score""": ANY(lowercase__       ), """token""": ANY(lowercase__       ), """token_str""": ANY(lowercase__       )},
											        ],
											    ]   ,		)









"""simple docstring"""

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







class    __lowercase     :







						"""simple docstring"""







						def __init__(self   ,		lowercase__       ):
											snake_case_					:		Union[str, Any] 					=					data
											snake_case_					:		List[str] 					=					[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							(lowercase__   ,		lowercase__       ):
											return ((n << b) | (n >> (32 - b))) & 0Xf_f_f_f_f_f_f_f







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Any 					=					B"""\x80""" + B"""\x00""" * (63 - (len(self.data       ) + 8) % 64)
											snake_case_					:		Tuple 					=					self.data + padding + struct.pack(""">Q"""   ,		8 * len(self.data       )       )
											return padded_data







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







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







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[Any] 					=					self.padding()
											snake_case_					:		Any 					=					self.split_blocks()
											for block in self.blocks:
																snake_case_					:		Any 					=					self.expand_block(lowercase__       )
																snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					:		List[Any] 					=					self.h
																for i in range(0   ,		80       ):
																					if 0 <= i < 20:
																										snake_case_					:		Optional[Any] 					=					(b & c) | ((~b) & d)
																										snake_case_					:		List[str] 					=					0X5_a_8_2_7_9_9_9
																					elif 20 <= i < 40:
																										snake_case_					:		Union[str, Any] 					=					b ^ c ^ d
																										snake_case_					:		Tuple 					=					0X6_e_d_9_e_b_a_1
																					elif 40 <= i < 60:
																										snake_case_					:		str 					=					(b & c) | (b & d) | (c & d)
																										snake_case_					:		List[str] 					=					0X8_f_1_b_b_c_d_c
																					elif 60 <= i < 80:
																										snake_case_					:		Tuple 					=					b ^ c ^ d
																										snake_case_					:		str 					=					0Xc_a_6_2_c_1_d_6
																					snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					,			snake_case_					:		Optional[Any] 					=					(
																					    self.rotate(lowercase__   ,		5       ) + f + e + k + expanded_block[i] & 0Xf_f_f_f_f_f_f_f,
																					    a,
																					    self.rotate(lowercase__   ,		30       ),
																					    c,
																					    d,
																					)
																snake_case_					:		Any 					=					(
																    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 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					snake_case_					:		Union[str, Any] 					=					b"""Test String"""
					assert SHAaHash(SCREAMING_SNAKE_CASE__			).final_hash() == hashlib.shaa(SCREAMING_SNAKE_CASE__			).hexdigest()  # noqa: S324







def 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					snake_case_					:		int 					=					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"""			)
					snake_case_					:		Optional[int] 					=					parser.parse_args()
					snake_case_					:		Optional[int] 					=					args.input_string
					# In any case hash input should be a bytestring
					if args.input_file:
										with open(args.input_file				,    """rb"""			) as f:
															snake_case_					:		List[str] 					=					f.read()
					else:
										snake_case_					:		Dict 					=					bytes(SCREAMING_SNAKE_CASE__				,    """utf-8"""			)
					print(SHAaHash(SCREAMING_SNAKE_CASE__			).final_hash()			)


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

			doctest.testmod()




