'''simple docstring'''





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




class 			__A :



    def __init__(self       :       str  ,     __a       :       Any					):
         UpperCAmelCase_			       =  data
         UpperCAmelCase_			       =  [0X67_45_23_01, 0Xef_cd_ab_89, 0X98_ba_dc_fe, 0X10_32_54_76, 0Xc3_d2_e1_f0]



    @staticmethod
    def    _lowercase		(__a       :       List[str]  ,     __a       :       str					):
         return ((n << b) | (n >> (32 - b))) & 0Xff_ff_ff_ff



    def    _lowercase		(self       :       List[str]					):
         UpperCAmelCase_			       =  B"\x80" + B"\x00" * (63 - (len(self.data					) + 8) % 64)
         UpperCAmelCase_			       =  self.data + padding + struct.pack(">Q"  ,     8 * len(self.data					)					)
         return padded_data



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



    def    _lowercase		(self       :       Union[str, Any]  ,     __a       :       Optional[int]					):
         UpperCAmelCase_			       =  list(struct.unpack(">16L"  ,     __a					)					) + [0] * 64
         for i in range(16  ,     80					):
              UpperCAmelCase_			       =  self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])  ,     1					)
         return w






    def    _lowercase		(self       :       Union[str, Any]					):
         UpperCAmelCase_			       =  self.padding()
         UpperCAmelCase_			       =  self.split_blocks()
         for block in self.blocks:
              UpperCAmelCase_			       =  self.expand_block(__a					)
              UpperCAmelCase_       ,					UpperCAmelCase_       ,					UpperCAmelCase_       ,					UpperCAmelCase_       ,					UpperCAmelCase_			       =  self.h
              for i in range(0  ,     80					):
                   if 0 <= i < 20:
                        UpperCAmelCase_			       =  (b & c) | ((~b) & d)
                        UpperCAmelCase_			       =  0X5a_82_79_99
                   elif 20 <= i < 40:
                        UpperCAmelCase_			       =  b ^ c ^ d
                        UpperCAmelCase_			       =  0X6e_d9_eb_a1
                   elif 40 <= i < 60:
                        UpperCAmelCase_			       =  (b & c) | (b & d) | (c & d)
                        UpperCAmelCase_			       =  0X8f_1b_bc_dc
                   elif 60 <= i < 80:
                        UpperCAmelCase_			       =  b ^ c ^ d
                        UpperCAmelCase_			       =  0Xca_62_c1_d6
                   UpperCAmelCase_       ,					UpperCAmelCase_       ,					UpperCAmelCase_       ,					UpperCAmelCase_       ,					UpperCAmelCase_			       =  (
                       self.rotate(__a  ,     5					) + f + e + k + expanded_block[i] & 0Xff_ff_ff_ff,
                       a,
                       self.rotate(__a  ,     30					),
                       c,
                       d,
                   )
              UpperCAmelCase_			       =  (
                  self.h[0] + a & 0Xff_ff_ff_ff,
                  self.h[1] + b & 0Xff_ff_ff_ff,
                  self.h[2] + c & 0Xff_ff_ff_ff,
                  self.h[3] + d & 0Xff_ff_ff_ff,
                  self.h[4] + e & 0Xff_ff_ff_ff,
              )
         return ("{:08x}" * 5).format(*self.h					)





def       lowerCAmelCase_							(   )       -> Union[str, Any]:


     '''simple docstring'''




     UpperCAmelCase_			       =  B"Test String"
     assert SHAaHash(snake_case_     ).final_hash() == hashlib.shaa(snake_case_     ).hexdigest()  # noqa: S324





def       lowerCAmelCase_							(   )       -> Dict:


     '''simple docstring'''




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


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

    doctest.testmod()









'''simple docstring'''





import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation







class        UpperCAmelCase_			(			unittest.TestCase      ):
    """simple docstring"""







    def lowerCamelCase			(       self   :	Union[str, Any]		):
          snake_case__    :       int       		= get_activation("""swish"""		)

          self.assertIsInstance(snake_case_					,	nn.SiLU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Optional[Any]		):
          snake_case__    :       int       		= get_activation("""silu"""		)

          self.assertIsInstance(snake_case_					,	nn.SiLU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Dict		):
          snake_case__    :       Union[str, Any]       		= get_activation("""mish"""		)

          self.assertIsInstance(snake_case_					,	nn.Mish		)

          self.assertEqual(act(torch.tensor(-200					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)




    def lowerCamelCase			(       self   :	Union[str, Any]		):
          snake_case__    :       int       		= get_activation("""gelu"""		)

          self.assertIsInstance(snake_case_					,	nn.GELU		)

          self.assertEqual(act(torch.tensor(-100					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertNotEqual(act(torch.tensor(-1					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(0					,	dtype=torch.floataa		)		).item()					,	0		)
          self.assertEqual(act(torch.tensor(20					,	dtype=torch.floataa		)		).item()					,	20		)
