

import argparse
import struct
import unittest



class SCREAMING_SNAKE_CASE     :







  def __init__(      self			:   str	,							lowerCAmelCase			:   Optional[int]   )							->     List[Any]:






     """simple docstring"""







     __lowerCAmelCase  :      List[Any]    =						data

     # Initialize hash values
     __lowerCAmelCase  :      str    =						[
         0X6a09e667,
         0Xbb67ae85,
         0X3c6ef372,
         0Xa54ff53a,
         0X510e527f,
         0X9b05688c,
         0X1f83d9ab,
         0X5be0cd19,
     ]

     # Initialize round constants
     __lowerCAmelCase  :      Union[str, Any]    =						[
         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,
     ]

     __lowerCAmelCase  :      List[str]    =						self.preprocessing(self.data   )
     self.final_hash()







  @staticmethod
  def 	SCREAMING_SNAKE_CASE   (      lowerCAmelCase			:   int   )							->     Any:






     """simple docstring"""







     __lowerCAmelCase  :      Any    =						B"""\x80""" + (B"""\x00""" * (63 - (len(lowerCamelCase__   ) + 8) % 64))
     __lowerCAmelCase  :      str    =						struct.pack(""">Q"""	,							(len(lowerCamelCase__   ) * 8)   )
     return data + padding + big_endian_integer







  def 	SCREAMING_SNAKE_CASE   (      self			:   List[str]   )							->     Any:






     """simple docstring"""







     __lowerCAmelCase  :      Tuple    =						[
         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[str]    =						list(struct.unpack(""">16L"""	,							lowerCamelCase__   )   )
        # add 48 0-ed integers
        words += [0] * 48

        __lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase  :      List[str]    =						self.hashes

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

              __lowerCAmelCase  :      Union[str, Any]    =						(
                  words[index - 16] + sa + words[index - 7] + sa
              ) % 0X100000000

           # Compression
           __lowerCAmelCase  :      int    =						self.ror(lowerCamelCase__	,							6   ) ^ self.ror(lowerCamelCase__	,							11   ) ^ self.ror(lowerCamelCase__	,							25   )
           __lowerCAmelCase  :      List[str]    =						(e & f) ^ ((~e & 0Xffffffff) & g)
           __lowerCAmelCase  :      Any    =						(
               h + sa + ch + self.round_constants[index] + words[index]
           ) % 0X100000000
           __lowerCAmelCase  :      Tuple    =						self.ror(lowerCamelCase__	,							2   ) ^ self.ror(lowerCamelCase__	,							13   ) ^ self.ror(lowerCamelCase__	,							22   )
           __lowerCAmelCase  :      Any    =						(a & b) ^ (a & c) ^ (b & c)
           __lowerCAmelCase  :      List[str]    =						(sa + maj) % 0X100000000

           __lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase   ,__lowerCAmelCase  :      Optional[int]    =						(
               g,
               f,
               e,
               ((d + tempa) % 0X100000000),
               c,
               b,
               a,
               ((tempa + tempa) % 0X100000000),
           )

        __lowerCAmelCase  :      Tuple    =						[a, b, c, d, e, f, g, h]

        # Modify final values
        __lowerCAmelCase  :      Optional[int]    =						[
            ((element + mutated_hash_values[index]) % 0X100000000)
            for index, element in enumerate(self.hashes   )
        ]

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







  def 	SCREAMING_SNAKE_CASE   (      self			:   List[Any]	,							lowerCAmelCase			:   Optional[int]	,							lowerCAmelCase			:   List[str]   )							->     Union[str, Any]:






     """simple docstring"""







     return 0Xffffffff & (value << (32 - rotations)) | (value >> rotations)






class SCREAMING_SNAKE_CASE     (  unittest.TestCase			):







  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]   )							->     Optional[Any]:






     """simple docstring"""







     import hashlib

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






def      snake_case_				()      ->     None:
   import doctest

   doctest.testmod()

   __lowerCAmelCase  :      Any    =						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  :      str    =						parser.parse_args()

   __lowerCAmelCase  :      Optional[Any]    =						args.input_string

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

   print(SHAaaa(lowercase_					).hash					)


if __name__ == "__main__":
   main()





import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, ClassLabel, Features
from .base import TaskTemplate



@dataclass(frozen=a_			)
class SCREAMING_SNAKE_CASE     (  a_			):
  """simple docstring"""






  lowerCamelCase   :      str										=field(default="audio-classification"       ,							metadata={"include_in_asdict_even_if_is_default": True}			)
  lowerCamelCase   :      ClassVar[Features]										=Features({"audio": Audio()}			)
  lowerCamelCase   :      ClassVar[Features]										=Features({"labels": ClassLabel}			)
  lowerCamelCase   :      str										="audio"
  lowerCamelCase   :      str										="labels"







  def 	SCREAMING_SNAKE_CASE   (      self			:   List[Any]	,							lowerCAmelCase			:   Dict   )							->     Dict:






     """simple docstring"""







     if self.label_column not in features:
        raise ValueError(f'''Column {self.label_column} is not present in features.'''   )
     if not isinstance(features[self.label_column]	,							lowerCAmelCase   ):
        raise ValueError(f'''Column {self.label_column} is not a ClassLabel.'''   )
     __lowerCAmelCase  :      Tuple    =						copy.deepcopy(self   )
     __lowerCAmelCase  :      Tuple    =						self.label_schema.copy()
     __lowerCAmelCase  :      Union[str, Any]    =						features[self.label_column]
     __lowerCAmelCase  :      Any    =						label_schema
     return task_template







  @property
  def 	SCREAMING_SNAKE_CASE   (      self			:   str   )							->     Dict[str, str]:






     """simple docstring"""







     return {
         self.audio_column: "audio",
         self.label_column: "labels",
     }


