code: 
  '''simple docstring'''
  
  from __future__ import annotations
  
  from string import ascii_letters
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase			,UpperCamelCase = None	) ->      str:
  		_UpperCamelCase       : Union[str, Any]    =      alphabet or ascii_letters
  
  		# The final result string
  		_UpperCamelCase       : str    =      ''''''
  
  		for character in input_string:
  				if character not in alpha:
  						# Append without encryption if character is not in the alphabet
  						result += character
  				else:
  						# Get the index of the new key and make sure it isn't too large
  						_UpperCamelCase       : str    =      (alpha.index(UpperCamelCase	) + key) % len(UpperCamelCase	)
  
  						# Append the encoded character to the alphabet
  						result += alpha[new_key]
  
  		return result
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase			,UpperCamelCase = None	) ->      str:
  		key *= -1
  
  		return encrypt(UpperCamelCase			,UpperCamelCase			,UpperCamelCase	)
  
  
  
  
  
  
  
  def 						snake_case__	(      UpperCamelCase			,UpperCamelCase = None	) ->      dict[int, str]:
  		_UpperCamelCase       : Dict    =      alphabet or ascii_letters
  
  		# To store data on all the combinations
  		_UpperCamelCase       : List[str]    =      {}
  
  		# Cycle through each combination
  		for key in range(1			,len(UpperCamelCase	) + 1	):
  				# Decrypt the message and store the result in the data
  				_UpperCamelCase       : Optional[int]    =      decrypt(UpperCamelCase			,UpperCamelCase			,UpperCamelCase	)
  
  		return brute_force_data
  
  
  if __name__ == "__main__":
  	while True:
  		print(f"""\n{'-' * 10}\n Menu\n{'-' * 10}""")
  		print(*["""1.Encrypt""", """2.Decrypt""", """3.BruteForce""", """4.Quit"""], sep="""\n""")
  
  		# get user input
  		_UpperCAmelCase   :      Optional[int] 						=  input("""\nWhat would you like to do?: """).strip() or """4"""
  
  		# run functions based on what the user chose
  		if choice not in ("1", "2", "3", "4"):
  			print("""Invalid choice, please enter a valid choice""")
  		elif choice == "1":
  			_UpperCAmelCase   :      int 						=  input("""Please enter the string to be encrypted: """)
  			_UpperCAmelCase   :      List[str] 						=  int(input("""Please enter off-set: """).strip())
  
  			print(encrypt(input_string, key))
  		elif choice == "2":
  			_UpperCAmelCase   :      Union[str, Any] 						=  input("""Please enter the string to be decrypted: """)
  			_UpperCAmelCase   :      str 						=  int(input("""Please enter off-set: """).strip())
  
  			print(decrypt(input_string, key))
  		elif choice == "3":
  			_UpperCAmelCase   :      Optional[Any] 						=  input("""Please enter the string to be decrypted: """)
  			_UpperCAmelCase   :      str 						=  brute_force(input_string)
  
  			for key, value in brute_force_data.items():
  				print(f"""Key: {key} | Message: {value}""")
  
  		elif choice == "4":
  			print("""Goodbye.""")
  			break
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  import unittest
  
  from transformers.image_processing_utils import get_size_dict
  
  class 			UpperCAmelCase				(					unittest.TestCase ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		def _lowercase  (    self     )				->    Dict:
  				# Test a dict with the wrong keys raises an error
  				_UpperCamelCase       : List[Any]    =      {'''wrong_key''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				_UpperCamelCase       : Dict    =      {'''height''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				_UpperCamelCase       : str    =      {'''width''': 224, '''shortest_edge''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				# Test a dict with the correct keys is returned as is
  				_UpperCamelCase       : Any    =      {'''height''': 224, '''width''': 224}
  				_UpperCamelCase       : Optional[int]    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					_snake_case     )
  
  				_UpperCamelCase       : Optional[Any]    =      {'''shortest_edge''': 224}
  				_UpperCamelCase       : int    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224}     )
  
  				_UpperCamelCase       : int    =      {'''longest_edge''': 224, '''shortest_edge''': 224}
  				_UpperCamelCase       : Tuple    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''longest_edge''': 224, '''shortest_edge''': 224}     )
  
  				# Test a single int value which  represents (size, size)
  				_UpperCamelCase       : Any    =      get_size_dict(224     )
  				self.assertEqual(_snake_case  ,					{'''height''': 224, '''width''': 224}     )
  
  				# Test a single int value which represents the shortest edge
  				_UpperCamelCase       : List[Any]    =      get_size_dict(224  ,					default_to_square=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224}     )
  
  				# Test a tuple of ints which represents (height, width)
  				_UpperCamelCase       : Any    =      get_size_dict((150, 200)     )
  				self.assertEqual(_snake_case  ,					{'''height''': 150, '''width''': 200}     )
  
  				# Test a tuple of ints which represents (width, height)
  				_UpperCamelCase       : List[str]    =      get_size_dict((150, 200)  ,					height_width_order=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''height''': 200, '''width''': 150}     )
  
  				# Test an int representing the shortest edge and max_size which represents the longest edge
  				_UpperCamelCase       : Any    =      get_size_dict(224  ,					max_size=256  ,					default_to_square=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224, '''longest_edge''': 256}     )
  
  				# Test int with default_to_square=True and max_size fails
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(224  ,					max_size=256  ,					default_to_square=_snake_case     )
  
  
  
  
  
  