'''simple docstring'''





import requests

_lowerCAmelCase  :Tuple  				=    """"""  # <-- Put your OpenWeatherMap appid here!
_lowerCAmelCase  :Optional[Any]  				=    """https://api.openweathermap.org/data/2.5/"""


def     __lowerCAmelCase						(       a_ = "Chicago"       ,      a_ = APPID		)      ->	dict:





     '''simple docstring'''





     return requests.get(URL_BASE + 'weather'       ,      params=locals()		).json()


def     __lowerCAmelCase						(       a_ = "Kolkata, India"       ,      a_ = APPID		)      ->	dict:





     '''simple docstring'''





     return requests.get(URL_BASE + 'forecast'       ,      params=locals()		).json()


def     __lowerCAmelCase						(       a_ = 55.68       ,      a_ = 12.57       ,      a_ = APPID		)      ->	dict:





     '''simple docstring'''





     return requests.get(URL_BASE + 'onecall'       ,      params=locals()		).json()


if __name__ == "__main__":
 from pprint import pprint

 while True:
  _lowerCAmelCase  :int  				=    input("""Enter a location:""").strip()
  if location:
   pprint(current_weather(location))
  else:
   break




'''simple docstring'''





import argparse
import struct
import unittest






class 				UpperCAmelCase :




    '''simple docstring'''







    def __init__(       self    ,							lowercase__ )							-> None:
         SCREAMING_SNAKE_CASE					:			List[str]    	=       data

         # Initialize hash values
         SCREAMING_SNAKE_CASE					:			str    	=       [
             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
         SCREAMING_SNAKE_CASE					:			List[Any]    	=       [
             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,
         ]

         SCREAMING_SNAKE_CASE					:			List[Any]    	=       self.preprocessing(self.data )
         self.final_hash()






    @staticmethod
    def       _UpperCamelCase    (       lowercase__ )							-> bytes:
         SCREAMING_SNAKE_CASE					:			str    	=       B'\x80' + (B'\x00' * (63 - (len(lowercase__ ) + 8) % 64))
         SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       struct.pack('>Q'    ,							(len(lowercase__ ) * 8) )
         return data + padding + big_endian_integer






    def       _UpperCamelCase    (       self )							-> None:
         # Convert into blocks of 64 bytes
         SCREAMING_SNAKE_CASE					:			Dict    	=       [
             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
              SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       list(struct.unpack('>16L'    ,							lowercase__ ) )
              # add 48 0-ed integers
              words += [0] * 48

              SCREAMING_SNAKE_CASE	,   SCREAMING_SNAKE_CASE	,   SCREAMING_SNAKE_CASE	,   SCREAMING_SNAKE_CASE	,   SCREAMING_SNAKE_CASE	,   SCREAMING_SNAKE_CASE	,   SCREAMING_SNAKE_CASE	,   SCREAMING_SNAKE_CASE					:			Dict    	=       self.hashes

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

                        SCREAMING_SNAKE_CASE					:			Tuple    	=       (
                            words[index - 16] + sa + words[index - 7] + sa
                        ) % 0X1_00_00_00_00

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

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

              SCREAMING_SNAKE_CASE					:			Union[str, Any]    	=       [a, b, c, d, e, f, g, h]

              # Modify final values
              SCREAMING_SNAKE_CASE					:			Tuple    	=       [
                  ((element + mutated_hash_values[index]) % 0X1_00_00_00_00)
                  for index, element in enumerate(self.hashes )
              ]

         SCREAMING_SNAKE_CASE					:			Tuple    	=       ''.join([hex(lowercase__ )[2:].zfill(8 ) for value in self.hashes] )






    def       _UpperCamelCase    (       self    ,							lowercase__    ,							lowercase__ )							-> int:
         return 0XFF_FF_FF_FF & (value << (32 - rotations)) | (value >> rotations)






class 				UpperCAmelCase (       unittest.TestCase ):




    '''simple docstring'''







    def       _UpperCamelCase    (       self )							-> None:
         import hashlib

         SCREAMING_SNAKE_CASE					:			Optional[Any]    	=       bytes('Test String'    ,							'utf-8' )
         self.assertEqual(SHAaaa(lowercase__ ).hash    ,							hashlib.shaaaa(lowercase__ ).hexdigest() )






def     __lowerCAmelCase						(       )      ->	None:





     '''simple docstring'''





     import doctest

     doctest.testmod()

     SCREAMING_SNAKE_CASE					:			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'		)

     SCREAMING_SNAKE_CASE					:			Tuple    	=       parser.parse_args()

     SCREAMING_SNAKE_CASE					:			List[Any]    	=       args.input_string

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

     print(SHAaaa(a_		).hash		)


if __name__ == "__main__":
 main()



