



'''simple docstring'''







import os
import pickle
import unittest
from collections import UserDict, namedtuple

import torch

from accelerate.test_utils.testing import require_cuda, require_torch_min_version
from accelerate.test_utils.training import RegressionModel
from accelerate.utils import (
    convert_outputs_to_fpaa,
    extract_model_from_parallel,
    find_device,
    listify,
    patch_environment,
    recursively_apply,
    send_to_device,
)


SCREAMING_SNAKE_CASE__     : List[str]				=   namedtuple("""ExampleNamedTuple""", """a b c""")




class 				__lowerCAmelCase(							unittest.TestCase      ):






			def 				_lowercase	(   self  :							Optional[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.randn(5      ,       2	)
					SCREAMING_SNAKE_CASE_						:int										=      torch.device('cuda'	) if torch.cuda.is_available() else torch.device('cpu'	)

					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      send_to_device(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta.cpu()      ,       SCREAMING_SNAKE_CASE	)	)

					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      send_to_device((tensor, [tensor, tensor], 1)      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta[0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta[1]      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta[1][0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta[1][1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta[2]      ,       1	)

					SCREAMING_SNAKE_CASE_						:Tuple										=      send_to_device({'a': tensor, 'b': [tensor, tensor], 'c': 1}      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['a'].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta['b']      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['b'][0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta['b'][1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta['c']      ,       1	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      send_to_device(ExampleNamedTuple(a=SCREAMING_SNAKE_CASE      ,       b=[tensor, tensor]      ,       c=1	)      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta.a.cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta.b      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta.b[0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta.b[1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta.c      ,       1	)

					SCREAMING_SNAKE_CASE_						:Tuple										=      send_to_device(UserDict({'a': tensor, 'b': [tensor, tensor], 'c': 1}	)      ,       SCREAMING_SNAKE_CASE	)
					self.assertIsInstance(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['a'].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertIsInstance(resulta['b']      ,       SCREAMING_SNAKE_CASE	)
					self.assertTrue(torch.equal(resulta['b'][0].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertTrue(torch.equal(resulta['b'][1].cpu()      ,       SCREAMING_SNAKE_CASE	)	)
					self.assertEqual(resulta['c']      ,       1	)






			def 				_lowercase	(   self  :							List[str]	):




					"""simple docstring"""







					with self.assertRaises(SCREAMING_SNAKE_CASE	) as cm:
							SCREAMING_SNAKE_CASE_						:Tuple										=      recursively_apply(torch.tensor      ,       (torch.tensor(1	), 1)      ,       error_on_other_type=SCREAMING_SNAKE_CASE	)
					self.assertEqual(
					    str(cm.exception	)      ,       'Unsupported types (<class \'int\'>) passed to `tensor`. Only nested list/tuple/dicts of objects that are valid for `is_torch_tensor` should be passed.'      ,       )






			def 				_lowercase	(   self  :							str	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[str]										=      torch.tensor([1, 2, 3, 4, 5]	)
					self.assertEqual(listify(SCREAMING_SNAKE_CASE	)      ,       [1, 2, 3, 4, 5]	)

					SCREAMING_SNAKE_CASE_						:Any										=      torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]	)
					self.assertEqual(listify(SCREAMING_SNAKE_CASE	)      ,       [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]	)
					self.assertEqual(
					    listify(SCREAMING_SNAKE_CASE	)      ,       [[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]	)






			def 				_lowercase	(   self  :							Tuple	):




					"""simple docstring"""







					with patch_environment(aa=1      ,       BB=2	):
							self.assertEqual(os.environ.get('AA'	)      ,       '1'	)
							self.assertEqual(os.environ.get('BB'	)      ,       '2'	)

					self.assertNotIn('AA'      ,       os.environ	)
					self.assertNotIn('BB'      ,       os.environ	)






			def 				_lowercase	(   self  :							Optional[int]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:str										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:Tuple										=      model.forward
					SCREAMING_SNAKE_CASE_						:Any										=      convert_outputs_to_fpaa(model.forward	)
					SCREAMING_SNAKE_CASE_						:Tuple										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE      ,       keep_fpaa_wrapper=SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:List[str]										=      pickle.dumps(SCREAMING_SNAKE_CASE	)






			@require_cuda
			def 				_lowercase	(   self  :							List[Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[str]										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:Tuple										=      model.forward
					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.cuda.amp.autocast(dtype=torch.floataa	)(model.forward	)
					SCREAMING_SNAKE_CASE_						:Any										=      convert_outputs_to_fpaa(model.forward	)
					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE      ,       keep_fpaa_wrapper=SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:List[Any]										=      pickle.dumps(SCREAMING_SNAKE_CASE	)






			@require_cuda
			@require_torch_min_version(version='2.0'	)
			def 				_lowercase	(   self  :							Dict	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Dict										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:Tuple										=      model.forward
					SCREAMING_SNAKE_CASE_						:int										=      torch.cuda.amp.autocast(dtype=torch.floataa	)(model.forward	)
					SCREAMING_SNAKE_CASE_						:int										=      convert_outputs_to_fpaa(model.forward	)
					SCREAMING_SNAKE_CASE_						:List[Any]										=      torch.compile(model.forward      ,       backend='inductor'	)
					SCREAMING_SNAKE_CASE_						:str										=      torch.randn(4      ,       10	).cuda()
					SCREAMING_SNAKE_CASE_						:int										=      model(SCREAMING_SNAKE_CASE	)






			def 				_lowercase	(   self  :							Union[str, Any]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[str]										=      RegressionModel()
					# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      torch.nn.parallel.DataParallel(SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:int										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE	)

					self.assertEqual(SCREAMING_SNAKE_CASE      ,       SCREAMING_SNAKE_CASE	)






			@require_torch_min_version(version='2.0'	)
			def 				_lowercase	(   self  :							Optional[int]	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:List[Any]										=      RegressionModel()
					SCREAMING_SNAKE_CASE_						:int										=      torch.compile(SCREAMING_SNAKE_CASE	)

					# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.nn.parallel.DataParallel(SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Tuple										=      torch.compile(SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      extract_model_from_parallel(SCREAMING_SNAKE_CASE	)

					self.assertEqual(compiled_model._orig_mod      ,       compiled_model_unwrapped._orig_mod	)






			def 				_lowercase	(   self  :							Optional[Any]	):




					"""simple docstring"""







					self.assertEqual(find_device([1, 'a', torch.tensor([1, 2, 3]	)]	)      ,       torch.device('cpu'	)	)
					self.assertEqual(find_device({'a': 1, 'b': torch.tensor([1, 2, 3]	)}	)      ,       torch.device('cpu'	)	)
					self.assertIsNone(find_device([1, 'a']	)	)


'''simple docstring'''

import random
import sys

__UpperCAmelCase												=   'ABCDEFGHIJKLMNOPQRSTUVWXYZ'



def        SCREAMING_SNAKE_CASE_  (	)       ->	None:
 SCREAMING_SNAKE_CASE  :  Dict								=		input('Enter message: '							)
 SCREAMING_SNAKE_CASE  :  Dict								=		'LFWOAYUISVKMNXPBDCRJTQEGHZ'
 SCREAMING_SNAKE_CASE  :  Tuple								=		input('Encrypt/Decrypt [e/d]: '							)

 check_valid_key(snake_case_							)

 if resp.lower().startswith('e'							):
  SCREAMING_SNAKE_CASE  :  str								=		'encrypt'
  SCREAMING_SNAKE_CASE  :  Optional[Any]								=		encrypt_message(snake_case_   ,     snake_case_							)
 elif resp.lower().startswith('d'							):
  SCREAMING_SNAKE_CASE  :  List[Any]								=		'decrypt'
  SCREAMING_SNAKE_CASE  :  List[str]								=		decrypt_message(snake_case_   ,     snake_case_							)

 print(f"""\n{mode.title()}ion: \n{translated}"""							)



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	str							)       ->	None:
 SCREAMING_SNAKE_CASE  :  int								=		list(snake_case_							)
 SCREAMING_SNAKE_CASE  :  Optional[Any]								=		list(snake_case_							)
 key_list.sort()
 letters_list.sort()

 if key_list != letters_list:
  sys.exit('Error in the key or symbol set.'							)



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	str   ,     snake_case_				:	str							)       ->	str:
 return translate_message(snake_case_   ,     snake_case_   ,     'encrypt'							)



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	str   ,     snake_case_				:	str							)       ->	str:
 return translate_message(snake_case_   ,     snake_case_   ,     'decrypt'							)



def        SCREAMING_SNAKE_CASE_  (	snake_case_				:	str   ,     snake_case_				:	str   ,     snake_case_				:	str							)       ->	str:
 SCREAMING_SNAKE_CASE  :  Any								=		''
 SCREAMING_SNAKE_CASE  :  Optional[Any]								=		LETTERS
 SCREAMING_SNAKE_CASE  :  List[Any]								=		key

 if mode == "decrypt":
  SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE  :  List[Any]								=		chars_b, chars_a

 for symbol in message:
  if symbol.upper() in chars_a:
   SCREAMING_SNAKE_CASE  :  Optional[Any]								=		chars_a.find(symbol.upper()							)
   if symbol.isupper():
    translated += chars_b[sym_index].upper()
   else:
    translated += chars_b[sym_index].lower()
  else:
   translated += symbol

 return translated



def        SCREAMING_SNAKE_CASE_  (	)       ->	str:
 SCREAMING_SNAKE_CASE  :  Dict								=		list(snake_case_							)
 random.shuffle(snake_case_							)
 return "".join(snake_case_							)


if __name__ == "__main__":
   main()


