


"""simple docstring"""
import string

import numpy







def   _a			(   _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE			)      ->			int:
							return b if a == 0 else greatest_common_divisor(b % a			,	__lowerCamelCase			)





class        __A       :





							'''simple docstring'''

							__lowercase:						List[Any]							 =      string.ascii_uppercase + string.digits
							# This cipher takes alphanumerics into account
							# i.e. a total of 36 characters

							# take x and return x % len(key_string)
							__lowercase:						List[Any]							 =      numpy.vectorize(lambda snake_case__: x % 36)

							__lowercase:						List[Any]							 =      numpy.vectorize(A_)



							def __init__(			self							: List[Any]						,    UpperCAmelCase_							: numpy.ndarray    )   ->Tuple:



														"""simple docstring"""



														snake_case_          =						self.modulus(_lowerCamelCase    )  # mod36 calc's on the encrypt key
														self.check_determinant()  # validate the determinant of the encryption key
														snake_case_          =						encrypt_key.shape[0]



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



														"""simple docstring"""



														return self.key_string.index(_lowerCamelCase    )



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



														"""simple docstring"""



														return self.key_string[round(_lowerCamelCase    )]



							def 						lowerCAmelCase    (			self							: Tuple    )   ->Union[str, Any]:



														"""simple docstring"""



														snake_case_          =						round(numpy.linalg.det(self.encrypt_key    )    )

														if det < 0:
																					snake_case_          =						det % len(self.key_string    )

														snake_case_          =						len(self.key_string    )
														if greatest_common_divisor(_lowerCamelCase						,    len(self.key_string    )    ) != 1:
																					snake_case_          =						(
																					    F"""determinant modular {req_l} of encryption key({det}) """
																					    F"""is not co prime w.r.t {req_l}.\nTry another key."""
																					)
																					raise ValueError(_lowerCamelCase    )



							def 						lowerCAmelCase    (			self							: Tuple						,    UpperCAmelCase_							: str    )   ->Optional[Any]:



														"""simple docstring"""



														snake_case_          =						[char for char in text.upper() if char in self.key_string]

														snake_case_          =						chars[-1]
														while len(_lowerCamelCase    ) % self.break_key != 0:
																					chars.append(_lowerCamelCase    )

														return "".join(_lowerCamelCase    )



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



														"""simple docstring"""



														snake_case_          =						self.process_text(text.upper()    )
														snake_case_          =						""""""

														for i in range(0						,    len(_lowerCamelCase    ) - self.break_key + 1						,    self.break_key    ):
																					snake_case_          =						text[i : i + self.break_key]
																					snake_case_          =						[self.replace_letters(_lowerCamelCase    ) for char in batch]
																					snake_case_          =						numpy.array([vec]    ).T
																					snake_case_          =						self.modulus(self.encrypt_key.dot(_lowerCamelCase    )    ).T.tolist()[
																					    0
																					]
																					snake_case_          =						"""""".join(
																					    self.replace_digits(_lowerCamelCase    ) for num in batch_encrypted    )
																					encrypted += encrypted_batch

														return encrypted



							def 						lowerCAmelCase    (			self							: Optional[Any]    )   ->Optional[Any]:



														"""simple docstring"""



														snake_case_          =						round(numpy.linalg.det(self.encrypt_key    )    )

														if det < 0:
																					snake_case_          =						det % len(self.key_string    )
														snake_case_          =						None
														for i in range(len(self.key_string    )    ):
																					if (det * i) % len(self.key_string    ) == 1:
																												snake_case_          =						i
																												break

														snake_case_          =						(
														    det_inv
														    * numpy.linalg.det(self.encrypt_key    )
														    * numpy.linalg.inv(self.encrypt_key    )
														)

														return self.to_int(self.modulus(_lowerCamelCase    )    )



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



														"""simple docstring"""



														snake_case_          =						self.make_decrypt_key()
														snake_case_          =						self.process_text(text.upper()    )
														snake_case_          =						""""""

														for i in range(0						,    len(_lowerCamelCase    ) - self.break_key + 1						,    self.break_key    ):
																					snake_case_          =						text[i : i + self.break_key]
																					snake_case_          =						[self.replace_letters(_lowerCamelCase    ) for char in batch]
																					snake_case_          =						numpy.array([vec]    ).T
																					snake_case_          =						self.modulus(decrypt_key.dot(_lowerCamelCase    )    ).T.tolist()[0]
																					snake_case_          =						"""""".join(
																					    self.replace_digits(_lowerCamelCase    ) for num in batch_decrypted    )
																					decrypted += decrypted_batch

														return decrypted







def   _a			(   )      ->			None:
							snake_case_          =						int(input("""Enter the order of the encryption key: """			)			)
							snake_case_          =						[]

							print("""Enter each row of the encryption key with space separated integers"""			)
							for _ in range(__lowerCamelCase			):
														snake_case_          =						[int(__lowerCamelCase			) for x in input().split()]
														hill_matrix.append(__lowerCamelCase			)

							snake_case_          =						HillCipher(numpy.array(__lowerCamelCase			)			)

							print("""Would you like to encrypt or decrypt some text? (1 or 2)"""			)
							snake_case_          =						input("""\n1. Encrypt\n2. Decrypt\n"""			)
							if option == "1":
														snake_case_          =						input("""What text would you like to encrypt?: """			)
														print("""Your encrypted text is:"""			)
														print(hc.encrypt(__lowerCamelCase			)			)
							elif option == "2":
														snake_case_          =						input("""What text would you like to decrypt?: """			)
														print("""Your decrypted text is:"""			)
														print(hc.decrypt(__lowerCamelCase			)			)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				main()







"""simple docstring"""
import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

__SCREAMING_SNAKE_CASE							:      Tuple						=      [
    'cross_validation.py',
    'gradient_accumulation.py',
    'local_sgd.py',
    'multi_process_metrics.py',
    'memory.py',
    'automatic_gradient_accumulation.py',
    'fsdp_with_peak_mem_tracking.py',
    'deepspeed_with_config_support.py',
    'megatron_lm_gpt_pretraining.py',
]





class        __A       (unittest.TestCase):





							'''simple docstring'''

							def 						lowerCAmelCase    (			self							: str						,    UpperCAmelCase_							: str						,    UpperCAmelCase_							: bool						,    UpperCAmelCase_							: str = None						,    UpperCAmelCase_							: list = None    )   ->List[Any]:



														"""simple docstring"""



														snake_case_          =						None
														snake_case_          =						os.path.abspath(os.path.join("""examples"""						,    """by_feature"""    )    )
														snake_case_          =						os.path.abspath("""examples"""    )
														for item in os.listdir(UpperCAmelCase_    ):
																					if item not in EXCLUDE_EXAMPLES:
																												snake_case_          =						os.path.join(UpperCAmelCase_						,    UpperCAmelCase_    )
																												if os.path.isfile(UpperCAmelCase_    ) and ".py" in item_path:
																																			with self.subTest(
																																			    tested_script=UpperCAmelCase_						,    feature_script=UpperCAmelCase_						,    tested_section="""main()""" if parser_only else """training_function()"""						,    ):
																																										snake_case_          =						compare_against_test(
																																										    os.path.join(UpperCAmelCase_						,    UpperCAmelCase_    )						,    UpperCAmelCase_						,    UpperCAmelCase_						,    UpperCAmelCase_    )
																																										snake_case_          =						"""\n""".join(UpperCAmelCase_    )
																																										if special_strings is not None:
																																																	for string in special_strings:
																																																								snake_case_          =						diff.replace(UpperCAmelCase_						,    """"""    )
																																										self.assertEqual(UpperCAmelCase_						,    """"""    )



							def 						lowerCAmelCase    (			self							: Tuple    )   ->List[Any]:



														"""simple docstring"""



														self.one_complete_example("""complete_nlp_example.py"""						,    UpperCAmelCase_    )
														self.one_complete_example("""complete_nlp_example.py"""						,    UpperCAmelCase_    )



							def 						lowerCAmelCase    (			self							: Tuple    )   ->Dict:



														"""simple docstring"""



														snake_case_          =						os.path.abspath(os.path.join("""examples"""						,    """cv_example.py"""    )    )
														snake_case_          =						[
														    """ """ * 16 + """{\n\n""",
														    """ """ * 20 + """\"accuracy\": eval_metric[\"accuracy\"],\n\n""",
														    """ """ * 20 + """\"f1\": eval_metric[\"f1\"],\n\n""",
														    """ """ * 20 + """\"train_loss\": total_loss.item() / len(train_dataloader),\n\n""",
														    """ """ * 20 + """\"epoch\": epoch,\n\n""",
														    """ """ * 16 + """},\n\n""",
														    """ """ * 16 + """step=epoch,\n""",
														    """ """ * 12,
														    """ """ * 8 + """for step, batch in enumerate(active_dataloader):\n""",
														]
														self.one_complete_example("""complete_cv_example.py"""						,    UpperCAmelCase_						,    UpperCAmelCase_						,    UpperCAmelCase_    )
														self.one_complete_example("""complete_cv_example.py"""						,    UpperCAmelCase_						,    UpperCAmelCase_						,    UpperCAmelCase_    )





@mock.patch.dict(os.environ  ,						{"""TESTING_MOCKED_DATALOADERS""": """1"""})
class        __A       (snake_case__):





							'''simple docstring'''

							__lowercase:						str							 =      False



							@classmethod
							def 						lowerCAmelCase    (			cls							: Any    )   ->List[str]:



														"""simple docstring"""



														super().setUpClass()
														snake_case_          =						tempfile.mkdtemp()
														snake_case_          =						os.path.join(cls._tmpdir						,    """default_config.yml"""    )

														write_basic_config(save_location=cls.configPath    )
														snake_case_          =						["""accelerate""", """launch""", """--config_file""", cls.configPath]



							@classmethod
							def 						lowerCAmelCase    (			cls							: List[str]    )   ->int:



														"""simple docstring"""



														super().tearDownClass()
														shutil.rmtree(cls._tmpdir    )



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



														"""simple docstring"""



														snake_case_          =						F"""
        examples/by_feature/checkpointing.py
        --checkpointing_steps epoch
        --output_dir {self.tmpdir}
        """.split()
														run_command(self._launch_args + testargs    )
														self.assertTrue(os.path.exists(os.path.join(self.tmpdir						,    """epoch_0"""    )    )    )



							def 						lowerCAmelCase    (			self							: Any    )   ->Optional[Any]:



														"""simple docstring"""



														snake_case_          =						F"""
        examples/by_feature/checkpointing.py
        --checkpointing_steps 1
        --output_dir {self.tmpdir}
        """.split()
														snake_case_          =						run_command(self._launch_args + testargs    )
														self.assertTrue(os.path.exists(os.path.join(self.tmpdir						,    """step_2"""    )    )    )



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



														"""simple docstring"""



														snake_case_          =						F"""
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir						,    "epoch_0"    )}
        """.split()
														snake_case_          =						run_command(self._launch_args + testargs						,    return_stdout=UpperCAmelCase_    )
														self.assertNotIn("""epoch 0:"""						,    UpperCAmelCase_    )
														self.assertIn("""epoch 1:"""						,    UpperCAmelCase_    )



							def 						lowerCAmelCase    (			self							: Optional[int]    )   ->Tuple:



														"""simple docstring"""



														snake_case_          =						F"""
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir						,    "step_2"    )}
        """.split()
														snake_case_          =						run_command(self._launch_args + testargs						,    return_stdout=UpperCAmelCase_    )
														if torch.cuda.is_available():
																					snake_case_          =						torch.cuda.device_count()
														else:
																					snake_case_          =						1
														if num_processes > 1:
																					self.assertNotIn("""epoch 0:"""						,    UpperCAmelCase_    )
																					self.assertIn("""epoch 1:"""						,    UpperCAmelCase_    )
														else:
																					self.assertIn("""epoch 0:"""						,    UpperCAmelCase_    )
																					self.assertIn("""epoch 1:"""						,    UpperCAmelCase_    )



							@slow
							def 						lowerCAmelCase    (			self							: Dict    )   ->Dict:



														"""simple docstring"""



														snake_case_          =						"""
        examples/by_feature/cross_validation.py
        --num_folds 2
        """.split()
														with mock.patch.dict(os.environ						,    {"""TESTING_MOCKED_DATALOADERS""": """0"""}    ):
																					snake_case_          =						run_command(self._launch_args + testargs						,    return_stdout=UpperCAmelCase_    )
																					snake_case_          =						re.findall("""({.+})"""						,    UpperCAmelCase_    )
																					snake_case_          =						[r for r in results if """accuracy""" in r][-1]
																					snake_case_          =						ast.literal_eval(UpperCAmelCase_    )
																					self.assertGreaterEqual(results["""accuracy"""]						,    0.75    )



							def 						lowerCAmelCase    (			self							: Optional[int]    )   ->int:



														"""simple docstring"""



														snake_case_          =						["""examples/by_feature/multi_process_metrics.py"""]
														run_command(self._launch_args + testargs    )



							@require_trackers
							@mock.patch.dict(os.environ						,    {"""WANDB_MODE""": """offline"""}    )
							def 						lowerCAmelCase    (			self							: Dict    )   ->Optional[Any]:



														"""simple docstring"""



														with tempfile.TemporaryDirectory() as tmpdir:
																					snake_case_          =						F"""
            examples/by_feature/tracking.py
            --with_tracking
            --project_dir {tmpdir}
            """.split()
																					run_command(self._launch_args + testargs    )
																					self.assertTrue(os.path.exists(os.path.join(UpperCAmelCase_						,    """tracking"""    )    )    )



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



														"""simple docstring"""



														snake_case_          =						["""examples/by_feature/gradient_accumulation.py"""]
														run_command(self._launch_args + testargs    )



							def 						lowerCAmelCase    (			self							: str    )   ->Dict:



														"""simple docstring"""



														snake_case_          =						["""examples/by_feature/local_sgd.py"""]
														run_command(self._launch_args + testargs    )



