"""simple docstring"""







import argparse
import struct
import unittest



class  _lowerCamelCase			:







				def __init__( self    :       Tuple			,					lowerCamelCase_    :       bytes						):

					"""simple docstring"""






					_lowercase :    Optional[int]							=							data

					# Initialize hash values
					_lowercase :    Any							=							[
					    0X6_A_0_9_E_6_6_7,
					    0XB_B_6_7_A_E_8_5,
					    0X3_C_6_E_F_3_7_2,
					    0XA_5_4_F_F_5_3_A,
					    0X5_1_0_E_5_2_7_F,
					    0X9_B_0_5_6_8_8_C,
					    0X1_F_8_3_D_9_A_B,
					    0X5_B_E_0_C_D_1_9,
					]

					# Initialize round constants
					_lowercase :    Optional[int]							=							[
					    0X4_2_8_A_2_F_9_8,
					    0X7_1_3_7_4_4_9_1,
					    0XB_5_C_0_F_B_C_F,
					    0XE_9_B_5_D_B_A_5,
					    0X3_9_5_6_C_2_5_B,
					    0X5_9_F_1_1_1_F_1,
					    0X9_2_3_F_8_2_A_4,
					    0XA_B_1_C_5_E_D_5,
					    0XD_8_0_7_A_A_9_8,
					    0X1_2_8_3_5_B_0_1,
					    0X2_4_3_1_8_5_B_E,
					    0X5_5_0_C_7_D_C_3,
					    0X7_2_B_E_5_D_7_4,
					    0X8_0_D_E_B_1_F_E,
					    0X9_B_D_C_0_6_A_7,
					    0XC_1_9_B_F_1_7_4,
					    0XE_4_9_B_6_9_C_1,
					    0XE_F_B_E_4_7_8_6,
					    0X0_F_C_1_9_D_C_6,
					    0X2_4_0_C_A_1_C_C,
					    0X2_D_E_9_2_C_6_F,
					    0X4_A_7_4_8_4_A_A,
					    0X5_C_B_0_A_9_D_C,
					    0X7_6_F_9_8_8_D_A,
					    0X9_8_3_E_5_1_5_2,
					    0XA_8_3_1_C_6_6_D,
					    0XB_0_0_3_2_7_C_8,
					    0XB_F_5_9_7_F_C_7,
					    0XC_6_E_0_0_B_F_3,
					    0XD_5_A_7_9_1_4_7,
					    0X0_6_C_A_6_3_5_1,
					    0X1_4_2_9_2_9_6_7,
					    0X2_7_B_7_0_A_8_5,
					    0X2_E_1_B_2_1_3_8,
					    0X4_D_2_C_6_D_F_C,
					    0X5_3_3_8_0_D_1_3,
					    0X6_5_0_A_7_3_5_4,
					    0X7_6_6_A_0_A_B_B,
					    0X8_1_C_2_C_9_2_E,
					    0X9_2_7_2_2_C_8_5,
					    0XA_2_B_F_E_8_A_1,
					    0XA_8_1_A_6_6_4_B,
					    0XC_2_4_B_8_B_7_0,
					    0XC_7_6_C_5_1_A_3,
					    0XD_1_9_2_E_8_1_9,
					    0XD_6_9_9_0_6_2_4,
					    0XF_4_0_E_3_5_8_5,
					    0X1_0_6_A_A_0_7_0,
					    0X1_9_A_4_C_1_1_6,
					    0X1_E_3_7_6_C_0_8,
					    0X2_7_4_8_7_7_4_C,
					    0X3_4_B_0_B_C_B_5,
					    0X3_9_1_C_0_C_B_3,
					    0X4_E_D_8_A_A_4_A,
					    0X5_B_9_C_C_A_4_F,
					    0X6_8_2_E_6_F_F_3,
					    0X7_4_8_F_8_2_E_E,
					    0X7_8_A_5_6_3_6_F,
					    0X8_4_C_8_7_8_1_4,
					    0X8_C_C_7_0_2_0_8,
					    0X9_0_B_E_F_F_F_A,
					    0XA_4_5_0_6_C_E_B,
					    0XB_E_F_9_A_3_F_7,
					    0XC_6_7_1_7_8_F_2,
					]

					_lowercase :    Any							=							self.preprocessing(self.data						)
					self.final_hash()







				@staticmethod
				def 							__UpperCAmelCase					( lowerCamelCase_    :       bytes						):

					"""simple docstring"""






					_lowercase :    Dict							=							b"\x80" + (b"\x00" * (6_3 - (len(__lowerCamelCase						) + 8) % 6_4))
					_lowercase :    List[Any]							=							struct.pack('>Q'			,					(len(__lowerCamelCase						) * 8)						)
					return data + padding + big_endian_integer







				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					_lowercase :    List[Any]							=							[
					    self.preprocessed_data[x : x + 6_4]
					    for x in range(0			,					len(self.preprocessed_data						)			,					6_4						)
					]

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

						_lowercase :    Optional[int]							=							self.hashes

						for index in range(0			,					6_4						):
							if index > 1_5:
								# modify the zero-ed indexes at the end of the array
								_lowercase :    List[Any]							=							(
								    self.ror(words[index - 1_5]			,					7						)
								    ^ self.ror(words[index - 1_5]			,					1_8						)
								    ^ (words[index - 1_5] >> 3)
								)
								_lowercase :    List[Any]							=							(
								    self.ror(words[index - 2]			,					1_7						)
								    ^ self.ror(words[index - 2]			,					1_9						)
								    ^ (words[index - 2] >> 1_0)
								)

								_lowercase :    Tuple							=							(
								    words[index - 1_6] + sa + words[index - 7] + sa
								) % 0X1_0_0_0_0_0_0_0_0

							# Compression
							_lowercase :    Tuple							=							self.ror(__lowerCamelCase			,					6						) ^ self.ror(__lowerCamelCase			,					1_1						) ^ self.ror(__lowerCamelCase			,					2_5						)
							_lowercase :    Optional[Any]							=							(e & f) ^ ((~e & 0XF_F_F_F_F_F_F_F) & g)
							_lowercase :    Union[str, Any]							=							(
							    h + sa + ch + self.round_constants[index] + words[index]
							) % 0X1_0_0_0_0_0_0_0_0
							_lowercase :    Any							=							self.ror(__lowerCamelCase			,					2						) ^ self.ror(__lowerCamelCase			,					1_3						) ^ self.ror(__lowerCamelCase			,					2_2						)
							_lowercase :    Any							=							(a & b) ^ (a & c) ^ (b & c)
							_lowercase :    Tuple							=							(sa + maj) % 0X1_0_0_0_0_0_0_0_0

							_lowercase :    List[Any]							=							(
							    g,
							    f,
							    e,
							    ((d + tempa) % 0X1_0_0_0_0_0_0_0_0),
							    c,
							    b,
							    a,
							    ((tempa + tempa) % 0X1_0_0_0_0_0_0_0_0),
							)

						_lowercase :    List[str]							=							[a, b, c, d, e, f, g, h]

						# Modify final values
						_lowercase :    Any							=							[
						    ((element + mutated_hash_values[index]) % 0X1_0_0_0_0_0_0_0_0)
						    for index, element in enumerate(self.hashes						)
						]

					_lowercase :    List[str]							=							"".join([hex(__lowerCamelCase						)[2:].zfill(8						) for value in self.hashes]						)







				def 							__UpperCAmelCase					( self    :       Optional[int]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					return 0XF_F_F_F_F_F_F_F & (value << (3_2 - rotations)) | (value >> rotations)



class  _lowerCamelCase			(unittest.TestCase     ):







				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					import hashlib

					_lowercase :    Union[str, Any]							=							bytes('Test String'			,					'utf-8'						)
					self.assertEqual(SHAaaa(__lowerCamelCase						).hash			,					hashlib.shaaaa(__lowerCamelCase						).hexdigest()						)



def      __lowerCAmelCase(		):






	"""simple docstring"""





	import doctest

	doctest.testmod()

	_lowercase :    List[str]							=							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'			)

	_lowercase :    Optional[Any]							=							parser.parse_args()

	_lowercase :    List[str]							=							args.input_string

	# hash input should be a bytestring
	if args.input_file:
		with open(args.input_file     ,'rb'			) as f:
			_lowercase :    List[str]							=							f.read()
	else:
		_lowercase :    int							=							bytes(_A     ,'utf-8'			)

	print(SHAaaa(_A			).hash			)


if __name__ == "__main__":
						main()
"""simple docstring"""







import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE



class  _lowerCamelCase			(__lowerCamelCase     ):
				_snake_case     =  ""
				_snake_case     =  (
				    None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
				)
				_snake_case     =  None  # compression type in fsspec. ex: "gzip"
				_snake_case     =  None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz







				def __init__( self    :       str			,					lowerCamelCase_    :       str = ""			,					lowerCamelCase_    :       Optional[str] = None			,					lowerCamelCase_    :       Optional[dict] = None			,					**lowerCamelCase_    :       List[str]						):

					"""simple docstring"""






					super().__init__(self			,					**lowerCamelCase_						)
					# always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
					_lowercase :    Union[str, Any]							=							fsspec.open(
					    lowerCamelCase_			,					mode='rb'			,					protocol=lowerCamelCase_			,					compression=self.compression			,					client_kwargs={
					        'requote_redirect_url': False,  # see https://github.com/huggingface/datasets/pull/5459
					        'trust_env': True,  # Enable reading proxy env variables.
					        **(target_options or {}).pop('client_kwargs'			,					{}						),  # To avoid issues if it was already passed.
					    }			,					**(target_options or {})			,					)
					_lowercase :    str							=							os.path.basename(self.file.path.split('::'						)[0]						)
					_lowercase :    Optional[int]							=							(
					    self.compressed_name[: self.compressed_name.rindex('.'						)]
					    if '.' in self.compressed_name
					    else self.compressed_name
					)
					_lowercase :    str							=							None







				@classmethod
				def 							__UpperCAmelCase					( cls    :       int			,					lowerCamelCase_    :       List[str]						):

					"""simple docstring"""






					return super()._strip_protocol(lowerCamelCase_						).lstrip('/'						)







				def 							__UpperCAmelCase					( self    :       Optional[Any]						):

					"""simple docstring"""






					if self.dir_cache is None:
						_lowercase :    Tuple							=							{**self.file.fs.info(self.file.path						), 'name': self.uncompressed_name}
						_lowercase :    int							=							{f['name']: f}







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       str						):

					"""simple docstring"""






					return self.file.open().read()







				def 							__UpperCAmelCase					( self    :       Dict			,					lowerCamelCase_    :       str			,					lowerCamelCase_    :       str = "rb"			,					lowerCamelCase_    :       str=None			,					lowerCamelCase_    :       str=True			,					lowerCamelCase_    :       Union[str, Any]=None			,					**lowerCamelCase_    :       Optional[int]			,					):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							self._strip_protocol(lowerCamelCase_						)
					if mode != "rb":
						raise ValueError(F'''Tried to read with mode {mode} on file {self.file.path} opened with mode \'rb\''''						)
					return self.file.open()



class  _lowerCamelCase			(__lowerCamelCase     ):
				_snake_case     =  "bz2"
				_snake_case     =  "bz2"
				_snake_case     =  ".bz2"



class  _lowerCamelCase			(__lowerCamelCase     ):
				_snake_case     =  "gzip"
				_snake_case     =  "gzip"
				_snake_case     =  ".gz"



class  _lowerCamelCase			(__lowerCamelCase     ):
				_snake_case     =  "lz4"
				_snake_case     =  "lz4"
				_snake_case     =  ".lz4"



class  _lowerCamelCase			(__lowerCamelCase     ):
				_snake_case     =  "xz"
				_snake_case     =  "xz"
				_snake_case     =  ".xz"



class  _lowerCamelCase			(__lowerCamelCase     ):
				_snake_case     =  "zstd"
				_snake_case     =  "zstd"
				_snake_case     =  ".zst"







				def __init__( self    :       Union[str, Any]			,					lowerCamelCase_    :       str			,					lowerCamelCase_    :       str = "rb"			,					lowerCamelCase_    :       Optional[str] = None			,					lowerCamelCase_    :       Optional[dict] = None			,					lowerCamelCase_    :       int = DEFAULT_BLOCK_SIZE			,					**lowerCamelCase_    :       int			,					):

					"""simple docstring"""






					super().__init__(
					    fo=lowerCamelCase_			,					mode=lowerCamelCase_			,					target_protocol=lowerCamelCase_			,					target_options=lowerCamelCase_			,					block_size=lowerCamelCase_			,					**lowerCamelCase_			,					)
					# We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
					#
					# File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
					#     out.close = close
					# AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
					#
					# see https://github.com/intake/filesystem_spec/issues/725
					_lowercase :    Any							=							self.file.__enter__



					class  _lowerCamelCase			:







									def __init__( self    :       Any			,					lowerCamelCase_    :       List[Any]						):

										"""simple docstring"""






										_lowercase :    Tuple							=							file_







									def __enter__( self    :       str						):

										"""simple docstring"""






										self._file.__enter__()
										return self







									def __exit__( self    :       Union[str, Any]			,					*lowerCamelCase_    :       Optional[Any]			,					**lowerCamelCase_    :       Union[str, Any]						):

										"""simple docstring"""






										self._file.__exit__(*lowerCamelCase_			,					**lowerCamelCase_						)







									def __iter__( self    :       Optional[int]						):

										"""simple docstring"""






										return iter(self._file						)







									def 							__UpperCAmelCase					( self    :       int						):

										"""simple docstring"""






										return next(self._file						)







									def __getattr__( self    :       List[str]			,					lowerCamelCase_    :       str						):

										"""simple docstring"""






										return getattr(self._file			,					lowerCamelCase_						)

					def fixed_enter(*lowerCamelCase_    :       List[Any]			,					**lowerCamelCase_    :       int						):
						return WrappedFile(_enter(*lowerCamelCase_			,					**lowerCamelCase_						)						)

					_lowercase :    Optional[int]							=							fixed_enter



