"""simple docstring"""







import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


_a  :  Dict=				get_tests_dir("fixtures/test_sentencepiece.model")

if is_torch_available():
	from transformers.models.mbart.modeling_mbart import shift_tokens_right

_a  :  Optional[int]=				250_004
_a  :  str=				250_020

@require_sentencepiece
@require_tokenizers
class 	UpperCamelCase    (					lowercase   ,			unittest.TestCase		):
				UpperCAmelCase       :   Optional[int]					=	MBartaaTokenizer
				UpperCAmelCase       :   Optional[Any]					=	MBartaaTokenizerFast
				UpperCAmelCase       :   Optional[Any]					=	True
				UpperCAmelCase       :   Tuple					=	True



				def       _lowercase  (self       :   str)					->			List[str]:
					super().setUp()

					# We have a SentencePiece fixture for testing
					__snake_case    :							str   	=				MBartaaTokenizer(_A			,						src_lang='en_XX'			,						tgt_lang='ro_RO'			,						keep_accents=_A)
					tokenizer.save_pretrained(self.tmpdirname)



				def       _lowercase  (self       :   Any)					->			Any:
					__snake_case    :							Optional[Any]   	=				'<s>'
					__snake_case    :							Any   	=				0

					self.assertEqual(self.get_tokenizer()._convert_token_to_id(_A)			,						_A)
					self.assertEqual(self.get_tokenizer()._convert_id_to_token(_A)			,						_A)



				def       _lowercase  (self       :   Any)					->			Optional[int]:
					__snake_case    :							int   	=				list(self.get_tokenizer().get_vocab().keys())

					self.assertEqual(vocab_keys[0]			,						'<s>')
					self.assertEqual(vocab_keys[1]			,						'<pad>')
					self.assertEqual(vocab_keys[-1]			,						'<mask>')
					self.assertEqual(len(_A)			,						10_54)



				def       _lowercase  (self       :   Dict)					->			Union[str, Any]:
					self.assertEqual(self.get_tokenizer().vocab_size			,						10_54)



				def       _lowercase  (self       :   str)					->			Union[str, Any]:
					__snake_case    :							Optional[int]   	=				MBartaaTokenizer(_A			,						src_lang='en_XX'			,						tgt_lang='ro_RO'			,						keep_accents=_A)

					__snake_case    :							Any   	=				tokenizer.tokenize('This is a test')
					self.assertListEqual(_A			,						['▁This', '▁is', '▁a', '▁t', 'est'])

					self.assertListEqual(
					    tokenizer.convert_tokens_to_ids(_A)			,						[value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]			,						)

					__snake_case    :							Optional[int]   	=				tokenizer.tokenize('I was born in 92000, and this is falsé.')
					self.assertListEqual(
					    _A			,						[SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '9', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', 'é', '.']			,						)
					__snake_case    :							int   	=				tokenizer.convert_tokens_to_ids(_A)
					self.assertListEqual(
					    _A			,						[
					        value + tokenizer.fairseq_offset
					        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
					    ]			,						)

					__snake_case    :							List[Any]   	=				tokenizer.convert_ids_to_tokens(_A)
					self.assertListEqual(
					    _A			,						[SPIECE_UNDERLINE + 'I', SPIECE_UNDERLINE + 'was', SPIECE_UNDERLINE + 'b', 'or', 'n', SPIECE_UNDERLINE + 'in', SPIECE_UNDERLINE + '', '<unk>', '2', '0', '0', '0', ',', SPIECE_UNDERLINE + 'and', SPIECE_UNDERLINE + 'this', SPIECE_UNDERLINE + 'is', SPIECE_UNDERLINE + 'f', 'al', 's', '<unk>', '.']			,						)



				@slow
				def       _lowercase  (self       :   List[str])					->			Dict:
					# fmt: off
					__snake_case    :							Dict   	=				{'input_ids': [[25_00_04, 1_10_62, 8_27_72, 7, 15, 8_27_72, 5_38, 5_15_29, 2_37, 1_71_98, 12_90, 2_06, 9, 21_51_75, 13_14, 1_36, 1_71_98, 12_90, 2_06, 9, 5_63_59, 42, 12_20_09, 9, 1_64_66, 16, 8_73_44, 45_37, 9, 47_17, 7_83_81, 6, 15_99_58, 7, 15, 2_44_80, 6_18, 4, 5_27, 2_26_93, 54_28, 4, 27_77, 2_44_80, 98_74, 4, 4_35_23, 5_94, 4, 8_03, 1_83_92, 3_31_89, 18, 4, 4_35_23, 2_44_47, 1_23_99, 1_00, 2_49_55, 8_36_58, 96_26, 14_40_57, 15, 8_39, 2_23_35, 16, 1_36, 2_49_55, 8_36_58, 8_34_79, 15, 3_91_02, 7_24, 16, 6_78, 6_45, 27_89, 13_28, 45_89, 42, 12_20_09, 11_57_74, 23, 8_05, 13_28, 4_68_76, 7, 1_36, 5_38_94, 19_40, 4_22_27, 4_11_59, 1_77_21, 8_23, 4_25, 4, 2_75_12, 9_87_22, 2_06, 1_36, 55_31, 49_70, 9_19, 1_73_36, 5, 2], [25_00_04, 2_00_80, 6_18, 83, 8_27_75, 47, 4_79, 9, 15_17, 73, 5_38_94, 3_33, 8_05_81, 11_01_17, 1_88_11, 52_56, 12_95, 51, 15_25_26, 2_97, 79_86, 3_90, 12_44_16, 5_38, 3_54_31, 2_14, 98, 1_50_44, 2_57_37, 1_36, 71_08, 4_37_01, 23, 7_56, 13_53_55, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [25_00_04, 5_81, 6_37_73, 11_94_55, 6, 14_77_97, 8_82_03, 7, 6_45, 70, 21, 32_85, 1_02_69, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
					# fmt: on

					self.tokenizer_integration_test_util(
					    expected_encoding=_A			,						model_name='facebook/mbart-large-50'			,						revision='d3913889c59cd5c9e456b269c376325eabad57e2'			,						)






				def       _lowercase  (self       :   Any)					->			Tuple:
					if not self.test_slow_tokenizer:
						# as we don't have a slow version, we can't compare the outputs between slow and fast versions
						return

					__snake_case    :							List[str]   	=				(self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-mbart50', {})
					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"):
							__snake_case    :							str   	=				self.rust_tokenizer_class.from_pretrained(_A			,						**_A)
							__snake_case    :							int   	=				self.tokenizer_class.from_pretrained(_A			,						**_A)

							__snake_case    :							Dict   	=				tempfile.mkdtemp()

							__snake_case    :							Union[str, Any]   	=				tokenizer_r.save_pretrained(_A)
							__snake_case    :							Optional[Any]   	=				tokenizer_p.save_pretrained(_A)

							# Checks it save with the same files + the tokenizer.json file for the fast one
							self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files))
							__snake_case    :							Tuple   	=				tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f)
							self.assertSequenceEqual(_A			,						_A)

							# Checks everything loads correctly in the same way
							__snake_case    :							List[Any]   	=				tokenizer_r.from_pretrained(_A)
							__snake_case    :							str   	=				tokenizer_p.from_pretrained(_A)

							# Check special tokens are set accordingly on Rust and Python
							for key in tokenizer_pp.special_tokens_map:
								self.assertTrue(hasattr(_A			,						_A))
								# self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
								# self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

							shutil.rmtree(_A)

							# Save tokenizer rust, legacy_format=True
							__snake_case    :							Optional[Any]   	=				tempfile.mkdtemp()

							__snake_case    :							Union[str, Any]   	=				tokenizer_r.save_pretrained(_A			,						legacy_format=_A)
							__snake_case    :							Any   	=				tokenizer_p.save_pretrained(_A)

							# Checks it save with the same files
							self.assertSequenceEqual(_A			,						_A)

							# Checks everything loads correctly in the same way
							__snake_case    :							List[str]   	=				tokenizer_r.from_pretrained(_A)
							__snake_case    :							Optional[int]   	=				tokenizer_p.from_pretrained(_A)

							# Check special tokens are set accordingly on Rust and Python
							for key in tokenizer_pp.special_tokens_map:
								self.assertTrue(hasattr(_A			,						_A))

							shutil.rmtree(_A)

							# Save tokenizer rust, legacy_format=False
							__snake_case    :							List[str]   	=				tempfile.mkdtemp()

							__snake_case    :							List[str]   	=				tokenizer_r.save_pretrained(_A			,						legacy_format=_A)
							__snake_case    :							Any   	=				tokenizer_p.save_pretrained(_A)

							# Checks it saved the tokenizer.json file
							self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files))

							# Checks everything loads correctly in the same way
							__snake_case    :							Union[str, Any]   	=				tokenizer_r.from_pretrained(_A)
							__snake_case    :							Optional[int]   	=				tokenizer_p.from_pretrained(_A)

							# Check special tokens are set accordingly on Rust and Python
							for key in tokenizer_pp.special_tokens_map:
								self.assertTrue(hasattr(_A			,						_A))

							shutil.rmtree(_A)







@require_torch
@require_sentencepiece
@require_tokenizers
class 	UpperCamelCase    (					unittest.TestCase		):
				UpperCAmelCase       :   str					=	"""facebook/mbart-large-50-one-to-many-mmt"""
				UpperCAmelCase       :   Optional[Any]					=	[
				    """ UN Chief Says There Is No Military Solution in Syria""",
				    """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""",
				]
				UpperCAmelCase       :   Tuple					=	[
				    """Şeful ONU declară că nu există o soluţie militară în Siria""",
				    """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"""
				    """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"""
				    """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
				]
				UpperCAmelCase       :   List[Any]					=	[EN_CODE, 8274, 12_7873, 2_5916, 7, 8622, 2071, 438, 6_7485, 53, 18_7895, 23, 5_1712, 2]



				@classmethod
				def       _lowercase  (cls       :   Any)					->			Union[str, Any]:
					__snake_case    :							MBartaaTokenizer   	=				MBartaaTokenizer.from_pretrained(
					    cls.checkpoint_name			,						src_lang='en_XX'			,						tgt_lang='ro_RO')
					__snake_case    :							List[Any]   	=				1
					return cls



				def       _lowercase  (self       :   List[str])					->			Optional[int]:
					self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ar_AR']			,						25_00_01)
					self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['en_EN']			,						25_00_04)
					self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ro_RO']			,						25_00_20)
					self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['mr_IN']			,						25_00_38)



				def       _lowercase  (self       :   Optional[Any])					->			Optional[int]:
					__snake_case    :							Dict   	=				self.tokenizer.batch_encode_plus(self.src_text).input_ids[0]
					self.assertListEqual(self.expected_src_tokens			,						_A)



				def       _lowercase  (self       :   Optional[int])					->			Tuple:
					self.assertIn(_A			,						self.tokenizer.all_special_ids)
					__snake_case    :							Optional[int]   	=				[RO_CODE, 8_84, 90_19, 96, 9, 9_16, 8_67_92, 36, 1_87_43, 1_55_96, 5, 2]
					__snake_case    :							Optional[Any]   	=				self.tokenizer.decode(_A			,						skip_special_tokens=_A)
					__snake_case    :							Dict   	=				self.tokenizer.decode(generated_ids[1:]			,						skip_special_tokens=_A)
					self.assertEqual(_A			,						_A)
					self.assertNotIn(self.tokenizer.eos_token			,						_A)



				def       _lowercase  (self       :   Union[str, Any])					->			List[Any]:
					__snake_case    :							str   	=				['this is gunna be a long sentence ' * 20]
					assert isinstance(src_text[0]			,						_A)
					__snake_case    :							Any   	=				10
					__snake_case    :							int   	=				self.tokenizer(_A			,						max_length=_A			,						truncation=_A).input_ids[0]
					self.assertEqual(ids[0]			,						_A)
					self.assertEqual(ids[-1]			,						2)
					self.assertEqual(len(_A)			,						_A)



				def       _lowercase  (self       :   List[str])					->			Any:
					self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR'])			,						[25_00_53, 25_00_01])



				def       _lowercase  (self       :   int)					->			Any:
					__snake_case    :							Optional[int]   	=				tempfile.mkdtemp()
					__snake_case    :							Union[str, Any]   	=				self.tokenizer.fairseq_tokens_to_ids
					self.tokenizer.save_pretrained(_A)
					__snake_case    :							int   	=				MBartaaTokenizer.from_pretrained(_A)
					self.assertDictEqual(new_tok.fairseq_tokens_to_ids			,						_A)



				@require_torch
				def       _lowercase  (self       :   Tuple)					->			Union[str, Any]:
					__snake_case    :							Any   	=				self.tokenizer(self.src_text			,						text_target=self.tgt_text			,						padding=_A			,						return_tensors='pt')
					__snake_case    :							int   	=				shift_tokens_right(batch['labels']			,						self.tokenizer.pad_token_id)

					# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
					assert batch.input_ids[1][0] == EN_CODE
					assert batch.input_ids[1][-1] == 2
					assert batch.labels[1][0] == RO_CODE
					assert batch.labels[1][-1] == 2
					assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]



				@require_torch
				def       _lowercase  (self       :   Optional[Any])					->			Optional[int]:
					__snake_case    :							Union[str, Any]   	=				self.tokenizer(
					    self.src_text			,						text_target=self.tgt_text			,						padding=_A			,						truncation=_A			,						max_length=len(self.expected_src_tokens)			,						return_tensors='pt'			,						)
					__snake_case    :							int   	=				shift_tokens_right(batch['labels']			,						self.tokenizer.pad_token_id)

					self.assertIsInstance(_A			,						_A)

					self.assertEqual((2, 14)			,						batch.input_ids.shape)
					self.assertEqual((2, 14)			,						batch.attention_mask.shape)
					__snake_case    :							Dict   	=				batch.input_ids.tolist()[0]
					self.assertListEqual(self.expected_src_tokens			,						_A)
					self.assertEqual(2			,						batch.decoder_input_ids[0, 0])  # decoder_start_token_id
					# Test that special tokens are reset
					self.assertEqual(self.tokenizer.prefix_tokens			,						[EN_CODE])
					self.assertEqual(self.tokenizer.suffix_tokens			,						[self.tokenizer.eos_token_id])



				def       _lowercase  (self       :   Tuple)					->			Optional[int]:
					__snake_case    :							Union[str, Any]   	=				self.tokenizer(self.src_text			,						padding=_A			,						truncation=_A			,						max_length=3			,						return_tensors='pt')
					__snake_case    :							List[str]   	=				self.tokenizer(
					    text_target=self.tgt_text			,						padding=_A			,						truncation=_A			,						max_length=10			,						return_tensors='pt')
					__snake_case    :							Any   	=				targets['input_ids']
					__snake_case    :							Union[str, Any]   	=				shift_tokens_right(_A			,						self.tokenizer.pad_token_id)

					self.assertEqual(batch.input_ids.shape[1]			,						3)
					self.assertEqual(batch.decoder_input_ids.shape[1]			,						10)






				@require_torch
				def       _lowercase  (self       :   Optional[Any])					->			Tuple:
					__snake_case    :							Any   	=				self.tokenizer._build_translation_inputs(
					    'A test'			,						return_tensors='pt'			,						src_lang='en_XX'			,						tgt_lang='ar_AR')

					self.assertEqual(
					    nested_simplify(_A)			,						{
					        # en_XX, A, test, EOS
					        'input_ids': [[25_00_04, 62, 30_34, 2]],
					        'attention_mask': [[1, 1, 1, 1]],
					        # ar_AR
					        'forced_bos_token_id': 25_00_01,
					    }			,						)






"""simple docstring"""







import string

import numpy
def 						__UpperCAmelCase       (					UpperCAmelCase_					:       int    ,							UpperCAmelCase_					:       int						)							->    int:

	'''simple docstring'''





	return b if a == 0 else greatest_common_divisor(b % a    ,							UpperCAmelCase_						)

class 	UpperCamelCase    :
				UpperCAmelCase       :   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)
				UpperCAmelCase       :   List[Any]					=	numpy.vectorize(lambda lowercase		: x % 36		)

				UpperCAmelCase       :   Dict					=	numpy.vectorize(lowercase		)



				def __init__(self       :   str			,						_A       :   numpy.ndarray)					->			None:
					__snake_case    :							str   	=				self.modulus(_A)  # mod36 calc's on the encrypt key
					self.check_determinant()  # validate the determinant of the encryption key
					__snake_case    :							Optional[Any]   	=				encrypt_key.shape[0]



				def       _lowercase  (self       :   Any			,						_A       :   str)					->			int:
					return self.key_string.index(_A)



				def       _lowercase  (self       :   Union[str, Any]			,						_A       :   int)					->			str:
					return self.key_string[round(_A)]



				def       _lowercase  (self       :   Optional[int])					->			None:
					__snake_case    :							Any   	=				round(numpy.linalg.det(self.encrypt_key))

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

					__snake_case    :							Tuple   	=				len(self.key_string)
					if greatest_common_divisor(_A			,						len(self.key_string)) != 1:
						__snake_case    :							List[str]   	=				(
						    f"determinant modular {req_l} of encryption key({det}) "
						    f"is not co prime w.r.t {req_l}.\nTry another key."
						)
						raise ValueError(_A)



				def       _lowercase  (self       :   Dict			,						_A       :   str)					->			str:
					__snake_case    :							str   	=				[char for char in text.upper() if char in self.key_string]

					__snake_case    :							int   	=				chars[-1]
					while len(_A) % self.break_key != 0:
						chars.append(_A)

					return "".join(_A)



				def       _lowercase  (self       :   Union[str, Any]			,						_A       :   str)					->			str:
					__snake_case    :							Any   	=				self.process_text(text.upper())
					__snake_case    :							Dict   	=				''

					for i in range(0			,						len(_A) - self.break_key + 1			,						self.break_key):
						__snake_case    :							Dict   	=				text[i : i + self.break_key]
						__snake_case    :							List[str]   	=				[self.replace_letters(_A) for char in batch]
						__snake_case    :							str   	=				numpy.array([vec]).T
						__snake_case    :							List[Any]   	=				self.modulus(self.encrypt_key.dot(_A)).T.tolist()[
						    0
						]
						__snake_case    :							str   	=				''.join(
						    self.replace_digits(_A) for num in batch_encrypted)
						encrypted += encrypted_batch

					return encrypted



				def       _lowercase  (self       :   Optional[int])					->			numpy.ndarray:
					__snake_case    :							List[Any]   	=				round(numpy.linalg.det(self.encrypt_key))

					if det < 0:
						__snake_case    :							int   	=				det % len(self.key_string)
					__snake_case    :							Optional[Any]   	=				None
					for i in range(len(self.key_string)):
						if (det * i) % len(self.key_string) == 1:
							__snake_case    :							Dict   	=				i
							break

					__snake_case    :							List[str]   	=				(
					    det_inv
					    * numpy.linalg.det(self.encrypt_key)
					    * numpy.linalg.inv(self.encrypt_key)
					)

					return self.to_int(self.modulus(_A))






				def       _lowercase  (self       :   int			,						_A       :   str)					->			str:
					__snake_case    :							int   	=				self.make_decrypt_key()
					__snake_case    :							List[str]   	=				self.process_text(text.upper())
					__snake_case    :							str   	=				''

					for i in range(0			,						len(_A) - self.break_key + 1			,						self.break_key):
						__snake_case    :							Optional[Any]   	=				text[i : i + self.break_key]
						__snake_case    :							Union[str, Any]   	=				[self.replace_letters(_A) for char in batch]
						__snake_case    :							Tuple   	=				numpy.array([vec]).T
						__snake_case    :							List[str]   	=				self.modulus(decrypt_key.dot(_A)).T.tolist()[0]
						__snake_case    :							str   	=				''.join(
						    self.replace_digits(_A) for num in batch_decrypted)
						decrypted += decrypted_batch

					return decrypted







def 						__UpperCAmelCase       (					)							->    None:

	'''simple docstring'''





	__snake_case    :							List[str]   	=				int(input('Enter the order of the encryption key: '						)						)
	__snake_case    :							str   	=				[]

	print('Enter each row of the encryption key with space separated integers'						)
	for _ in range(UpperCAmelCase_						):
		__snake_case    :							Union[str, Any]   	=				[int(UpperCAmelCase_						) for x in input().split()]
		hill_matrix.append(UpperCAmelCase_						)

	__snake_case    :							Dict   	=				HillCipher(numpy.array(UpperCAmelCase_						)						)

	print('Would you like to encrypt or decrypt some text? (1 or 2)'						)
	__snake_case    :							Optional[Any]   	=				input('\n1. Encrypt\n2. Decrypt\n'						)
	if option == "1":
		__snake_case    :							int   	=				input('What text would you like to encrypt?: '						)
		print('Your encrypted text is:'						)
		print(hc.encrypt(UpperCAmelCase_						)						)
	elif option == "2":
		__snake_case    :							Tuple   	=				input('What text would you like to decrypt?: '						)
		print('Your decrypted text is:'						)
		print(hc.decrypt(UpperCAmelCase_						)						)


if __name__ == "__main__":
	import doctest

	doctest.testmod()

	main()





