





import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    MODEL_FOR_PRETRAINING_MAPPING,
				    NezhaForMaskedLM,
				    NezhaForMultipleChoice,
				    NezhaForNextSentencePrediction,
				    NezhaForPreTraining,
				    NezhaForQuestionAnswering,
				    NezhaForSequenceClassification,
				    NezhaForTokenClassification,
				    NezhaModel,
				)
				from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST
class        snake_case_		:







		def __init__(		self			,     __lowercase			,     __lowercase=1_3			,     __lowercase=7			,     __lowercase=True			,     __lowercase=True			,     __lowercase=True			,     __lowercase=True			,     __lowercase=9_9			,     __lowercase=3_2			,     __lowercase=5			,     __lowercase=4			,     __lowercase=3_7			,     __lowercase="gelu"			,     __lowercase=0.1			,     __lowercase=0.1			,     __lowercase=1_2_8			,     __lowercase=3_2			,     __lowercase=1_6			,     __lowercase=2			,     __lowercase=0.0_2			,     __lowercase=3			,     __lowercase=4			,     __lowercase=None			,     )				->   List[str]:
				lowerCamelCase   : int								=parent
				lowerCamelCase   : Optional[int]								=batch_size
				lowerCamelCase   : Any								=seq_length
				lowerCamelCase   : List[Any]								=is_training
				lowerCamelCase   : List[Any]								=use_input_mask
				lowerCamelCase   : Any								=use_token_type_ids
				lowerCamelCase   : Dict								=use_labels
				lowerCamelCase   : Union[str, Any]								=vocab_size
				lowerCamelCase   : Dict								=hidden_size
				lowerCamelCase   : Optional[int]								=num_hidden_layers
				lowerCamelCase   : Tuple								=num_attention_heads
				lowerCamelCase   : Optional[int]								=intermediate_size
				lowerCamelCase   : Tuple								=hidden_act
				lowerCamelCase   : Optional[int]								=hidden_dropout_prob
				lowerCamelCase   : Dict								=attention_probs_dropout_prob
				lowerCamelCase   : Union[str, Any]								=max_position_embeddings
				lowerCamelCase   : Union[str, Any]								=type_vocab_size
				lowerCamelCase   : List[Any]								=type_sequence_label_size
				lowerCamelCase   : Any								=initializer_range
				lowerCamelCase   : Tuple								=num_labels
				lowerCamelCase   : Dict								=num_choices
				lowerCamelCase   : List[str]								=scope







		def 			__lowercase   (		self   )				->   Optional[Any]:
				lowerCamelCase   : List[Any]								=ids_tensor([self.batch_size, self.seq_length]			,     self.vocab_size   )

				lowerCamelCase   : List[Any]								=None
				if self.use_input_mask:
						lowerCamelCase   : str								=random_attention_mask([self.batch_size, self.seq_length]   )

				lowerCamelCase   : int								=None
				if self.use_token_type_ids:
						lowerCamelCase   : Dict								=ids_tensor([self.batch_size, self.seq_length]			,     self.type_vocab_size   )

				lowerCamelCase   : Union[str, Any]								=None
				lowerCamelCase   : Tuple								=None
				lowerCamelCase   : str								=None
				if self.use_labels:
						lowerCamelCase   : List[str]								=ids_tensor([self.batch_size]			,     self.type_sequence_label_size   )
						lowerCamelCase   : Dict								=ids_tensor([self.batch_size, self.seq_length]			,     self.num_labels   )
						lowerCamelCase   : Any								=ids_tensor([self.batch_size]			,     self.num_choices   )

				lowerCamelCase   : Optional[int]								=self.get_config()

				return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







		def 			__lowercase   (		self   )				->   Optional[Any]:
				return NezhaConfig(
				    vocab_size=self.vocab_size			,     hidden_size=self.hidden_size			,     num_hidden_layers=self.num_hidden_layers			,     num_attention_heads=self.num_attention_heads			,     intermediate_size=self.intermediate_size			,     hidden_act=self.hidden_act			,     hidden_dropout_prob=self.hidden_dropout_prob			,     attention_probs_dropout_prob=self.attention_probs_dropout_prob			,     max_position_embeddings=self.max_position_embeddings			,     type_vocab_size=self.type_vocab_size			,     is_decoder=__lowercase			,     initializer_range=self.initializer_range			,     )







		def 			__lowercase   (		self   )				->   Tuple:
				(
				    lowerCamelCase   
				)   : List[Any]								=self.prepare_config_and_inputs()

				lowerCamelCase   : Tuple								=True
				lowerCamelCase   : List[Any]								=floats_tensor([self.batch_size, self.seq_length, self.hidden_size]   )
				lowerCamelCase   : Tuple								=ids_tensor([self.batch_size, self.seq_length]			,     vocab_size=2   )

				return (
				    config,
				    input_ids,
				    token_type_ids,
				    input_mask,
				    sequence_labels,
				    token_labels,
				    choice_labels,
				    encoder_hidden_states,
				    encoder_attention_mask,
				)







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   Optional[Any]:
				lowerCamelCase   : Dict								=NezhaModel(config=__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : Dict								=model(__lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase   )
				lowerCamelCase   : Optional[int]								=model(__lowercase			,     token_type_ids=__lowercase   )
				lowerCamelCase   : List[Any]								=model(__lowercase   )
				self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)   )
				self.parent.assertEqual(result.pooler_output.shape			,     (self.batch_size, self.hidden_size)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     )				->   str:
				lowerCamelCase   : Tuple								=True
				lowerCamelCase   : Optional[int]								=NezhaModel(__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : Optional[Any]								=model(
				    __lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     encoder_hidden_states=__lowercase			,     encoder_attention_mask=__lowercase			,     )
				lowerCamelCase   : int								=model(
				    __lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     encoder_hidden_states=__lowercase			,     )
				lowerCamelCase   : int								=model(__lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase   )
				self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)   )
				self.parent.assertEqual(result.pooler_output.shape			,     (self.batch_size, self.hidden_size)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   int:
				lowerCamelCase   : Union[str, Any]								=NezhaForMaskedLM(config=__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : Any								=model(__lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     labels=__lowercase   )
				self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   Tuple:
				lowerCamelCase   : Any								=NezhaForNextSentencePrediction(config=__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : List[str]								=model(
				    __lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     labels=__lowercase			,     )
				self.parent.assertEqual(result.logits.shape			,     (self.batch_size, 2)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   str:
				lowerCamelCase   : str								=NezhaForPreTraining(config=__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : str								=model(
				    __lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     labels=__lowercase			,     next_sentence_label=__lowercase			,     )
				self.parent.assertEqual(result.prediction_logits.shape			,     (self.batch_size, self.seq_length, self.vocab_size)   )
				self.parent.assertEqual(result.seq_relationship_logits.shape			,     (self.batch_size, 2)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   List[str]:
				lowerCamelCase   : Any								=NezhaForQuestionAnswering(config=__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : Optional[Any]								=model(
				    __lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     start_positions=__lowercase			,     end_positions=__lowercase			,     )
				self.parent.assertEqual(result.start_logits.shape			,     (self.batch_size, self.seq_length)   )
				self.parent.assertEqual(result.end_logits.shape			,     (self.batch_size, self.seq_length)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   int:
				lowerCamelCase   : List[Any]								=self.num_labels
				lowerCamelCase   : List[Any]								=NezhaForSequenceClassification(__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : int								=model(__lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     labels=__lowercase   )
				self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_labels)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   Any:
				lowerCamelCase   : Optional[Any]								=self.num_labels
				lowerCamelCase   : str								=NezhaForTokenClassification(config=__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : Dict								=model(__lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     labels=__lowercase   )
				self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.seq_length, self.num_labels)   )







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase   )				->   Dict:
				lowerCamelCase   : Any								=self.num_choices
				lowerCamelCase   : List[str]								=NezhaForMultipleChoice(config=__lowercase   )
				model.to(__lowercase   )
				model.eval()
				lowerCamelCase   : Union[str, Any]								=input_ids.unsqueeze(1   ).expand(-1			,     self.num_choices			,     -1   ).contiguous()
				lowerCamelCase   : Tuple								=token_type_ids.unsqueeze(1   ).expand(-1			,     self.num_choices			,     -1   ).contiguous()
				lowerCamelCase   : List[str]								=input_mask.unsqueeze(1   ).expand(-1			,     self.num_choices			,     -1   ).contiguous()
				lowerCamelCase   : List[str]								=model(
				    __lowercase			,     attention_mask=__lowercase			,     token_type_ids=__lowercase			,     labels=__lowercase			,     )
				self.parent.assertEqual(result.logits.shape			,     (self.batch_size, self.num_choices)   )







		def 			__lowercase   (		self   )				->   Union[str, Any]:
				lowerCamelCase   : int								=self.prepare_config_and_inputs()
				(
				    lowerCamelCase   
				)   : Tuple								=config_and_inputs
				lowerCamelCase   : str								={'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
				return config, inputs_dict

@require_torch
class        snake_case_		(			_A						,					_A						,					_A						,					unittest.TestCase):
		lowerCamelCase    :Optional[Any]						=     (
		    (
		        NezhaModel,
		        NezhaForMaskedLM,
		        NezhaForMultipleChoice,
		        NezhaForNextSentencePrediction,
		        NezhaForPreTraining,
		        NezhaForQuestionAnswering,
		        NezhaForSequenceClassification,
		        NezhaForTokenClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		lowerCamelCase    :str						=     (
		    {
		        "feature-extraction": NezhaModel,
		        "fill-mask": NezhaForMaskedLM,
		        "question-answering": NezhaForQuestionAnswering,
		        "text-classification": NezhaForSequenceClassification,
		        "token-classification": NezhaForTokenClassification,
		        "zero-shot": NezhaForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		lowerCamelCase    :Dict						=     True







		def 			__lowercase   (		self			,     __lowercase			,     __lowercase			,     __lowercase=False   )				->   Optional[int]:
				lowerCamelCase   : List[Any]								=super()._prepare_for_class(__lowercase			,     __lowercase			,     return_labels=__lowercase   )

				if return_labels:
						if model_class in get_values(__lowercase   ):
								lowerCamelCase   : Tuple								=torch.zeros(
								    (self.model_tester.batch_size, self.model_tester.seq_length)			,     dtype=torch.long			,     device=__lowercase   )
								lowerCamelCase   : List[Any]								=torch.zeros(
								    self.model_tester.batch_size			,     dtype=torch.long			,     device=__lowercase   )
				return inputs_dict







		def 			__lowercase   (		self   )				->   List[str]:
				lowerCamelCase   : List[str]								=NezhaModelTester(self   )
				lowerCamelCase   : str								=ConfigTester(self			,     config_class=__lowercase			,     hidden_size=3_7   )







		def 			__lowercase   (		self   )				->   Union[str, Any]:
				self.config_tester.run_common_tests()







		def 			__lowercase   (		self   )				->   Any:
				lowerCamelCase   : Tuple								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__lowercase   )







		def 			__lowercase   (		self   )				->   Dict:
				lowerCamelCase   : int								=self.model_tester.prepare_config_and_inputs_for_decoder()
				self.model_tester.create_and_check_model_as_decoder(*__lowercase   )







		def 			__lowercase   (		self   )				->   Any:
				# This regression test was failing with PyTorch < 1.3
				(
				    lowerCamelCase   
				)   : Optional[int]								=self.model_tester.prepare_config_and_inputs_for_decoder()

				lowerCamelCase   : str								=None

				self.model_tester.create_and_check_model_as_decoder(
				    __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     __lowercase			,     )







		def 			__lowercase   (		self   )				->   Optional[int]:
				lowerCamelCase   : Optional[int]								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_lm(*__lowercase   )







		def 			__lowercase   (		self   )				->   List[str]:
				lowerCamelCase   : List[str]								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_multiple_choice(*__lowercase   )







		def 			__lowercase   (		self   )				->   List[str]:
				lowerCamelCase   : Any								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_next_sequence_prediction(*__lowercase   )







		def 			__lowercase   (		self   )				->   str:
				lowerCamelCase   : Tuple								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_pretraining(*__lowercase   )







		def 			__lowercase   (		self   )				->   Tuple:
				lowerCamelCase   : Dict								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_question_answering(*__lowercase   )







		def 			__lowercase   (		self   )				->   List[Any]:
				lowerCamelCase   : Union[str, Any]								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_sequence_classification(*__lowercase   )







		def 			__lowercase   (		self   )				->   Tuple:
				lowerCamelCase   : List[Any]								=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_token_classification(*__lowercase   )







		@slow
		def 			__lowercase   (		self   )				->   Optional[Any]:
				for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowerCamelCase   : Optional[int]								=NezhaModel.from_pretrained(__lowercase   )
						self.assertIsNotNone(__lowercase   )







		@slow
		@require_torch_gpu
		def 			__lowercase   (		self   )				->   Optional[Any]:
				lowerCamelCase   : Tuple								=self.model_tester.prepare_config_and_inputs_for_common()
				for model_class in self.all_model_classes:
						# NezhaForMultipleChoice behaves incorrectly in JIT environments.
						if model_class == NezhaForMultipleChoice:
								return

						lowerCamelCase   : List[str]								=True
						lowerCamelCase   : int								=model_class(config=__lowercase   )

						lowerCamelCase   : Dict								=self._prepare_for_class(__lowercase			,     __lowercase   )
						lowerCamelCase   : List[Any]								=torch.jit.trace(
						    __lowercase			,     (inputs_dict['''input_ids'''].to('''cpu'''   ), inputs_dict['''attention_mask'''].to('''cpu'''   ))   )

						with tempfile.TemporaryDirectory() as tmp:
								torch.jit.save(__lowercase			,     os.path.join(__lowercase			,     '''bert.pt'''   )   )
								lowerCamelCase   : int								=torch.jit.load(os.path.join(__lowercase			,     '''bert.pt'''   )			,     map_location=__lowercase   )
								loaded(inputs_dict['''input_ids'''].to(__lowercase   )			,     inputs_dict['''attention_mask'''].to(__lowercase   )   )

@require_torch
class        snake_case_		(			unittest.TestCase):







		@slow
		def 			__lowercase   (		self   )				->   int:
				lowerCamelCase   : str								=NezhaModel.from_pretrained('''sijunhe/nezha-cn-base'''   )
				lowerCamelCase   : Union[str, Any]								=torch.tensor([[0, 1, 2, 3, 4, 5]]   )
				lowerCamelCase   : Any								=torch.tensor([[0, 1, 1, 1, 1, 1]]   )
				with torch.no_grad():
						lowerCamelCase   : Any								=model(__lowercase			,     attention_mask=__lowercase   )[0]
				lowerCamelCase   : Optional[Any]								=torch.Size((1, 6, 7_6_8)   )
				self.assertEqual(output.shape			,     __lowercase   )
				lowerCamelCase   : List[str]								=torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]]   )

				self.assertTrue(torch.allclose(output[:, 1:4, 1:4]			,     __lowercase			,     atol=1e-4   )   )







		@slow
		def 			__lowercase   (		self   )				->   Any:
				lowerCamelCase   : Any								=NezhaForMaskedLM.from_pretrained('''sijunhe/nezha-cn-base'''   )
				lowerCamelCase   : Any								=torch.tensor([[0, 1, 2, 3, 4, 5]]   )
				lowerCamelCase   : Any								=torch.tensor([[1, 1, 1, 1, 1, 1]]   )
				with torch.no_grad():
						lowerCamelCase   : Union[str, Any]								=model(__lowercase			,     attention_mask=__lowercase   )[0]
				lowerCamelCase   : Optional[Any]								=torch.Size((1, 6, 2_1_1_2_8)   )
				self.assertEqual(output.shape			,     __lowercase   )
				lowerCamelCase   : str								=torch.tensor(
				    [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]]   )

				self.assertTrue(torch.allclose(output[:, 1:4, 1:4]			,     __lowercase			,     atol=1e-4   )   )








import string

import numpy


def 					A__	(       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_		)   ->     int:
		return b if a == 0 else greatest_common_divisor(b % a							,       SCREAMING_SNAKE_CASE_		)
class        snake_case_		:
		lowerCamelCase    :Tuple						=     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)
		lowerCamelCase    :str						=     numpy.vectorize(lambda _A: x % 36)

		lowerCamelCase    :str						=     numpy.vectorize(_A)







		def __init__(		self			,     __lowercase   )				->   None:
				lowerCamelCase   : Union[str, Any]								=self.modulus(__lowercase   )  # mod36 calc's on the encrypt key
				self.check_determinant()  # validate the determinant of the encryption key
				lowerCamelCase   : int								=encrypt_key.shape[0]







		def 			__lowercase   (		self			,     __lowercase   )				->   int:
				return self.key_string.index(__lowercase   )







		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				return self.key_string[round(__lowercase   )]







		def 			__lowercase   (		self   )				->   None:
				lowerCamelCase   : Tuple								=round(numpy.linalg.det(self.encrypt_key   )   )

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

				lowerCamelCase   : Dict								=len(self.key_string   )
				if greatest_common_divisor(__lowercase			,     len(self.key_string   )   ) != 1:
						lowerCamelCase   : Union[str, Any]								=(
						    F"determinant modular {req_l} of encryption key({det}) "
						    F"is not co prime w.r.t {req_l}.\nTry another key."
						)
						raise ValueError(__lowercase   )







		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				lowerCamelCase   : int								=[char for char in text.upper() if char in self.key_string]

				lowerCamelCase   : Tuple								=chars[-1]
				while len(__lowercase   ) % self.break_key != 0:
						chars.append(__lowercase   )

				return "".join(__lowercase   )







		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				lowerCamelCase   : str								=self.process_text(text.upper()   )
				lowerCamelCase   : Optional[int]								=''''''

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

				return encrypted







		def 			__lowercase   (		self   )				->   numpy.ndarray:
				lowerCamelCase   : List[Any]								=round(numpy.linalg.det(self.encrypt_key   )   )

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

				lowerCamelCase   : Union[str, Any]								=(
				    det_inv
				    * numpy.linalg.det(self.encrypt_key   )
				    * numpy.linalg.inv(self.encrypt_key   )
				)

				return self.to_int(self.modulus(__lowercase   )   )







		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				lowerCamelCase   : Optional[int]								=self.make_decrypt_key()
				lowerCamelCase   : int								=self.process_text(text.upper()   )
				lowerCamelCase   : Any								=''''''

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

				return decrypted


def 					A__	(       )   ->     None:
		lowerCamelCase   : str								=int(input('''Enter the order of the encryption key: '''		)		)
		lowerCamelCase   : Optional[Any]								=[]

		print('''Enter each row of the encryption key with space separated integers'''		)
		for _ in range(SCREAMING_SNAKE_CASE_		):
				lowerCamelCase   : Optional[Any]								=[int(SCREAMING_SNAKE_CASE_		) for x in input().split()]
				hill_matrix.append(SCREAMING_SNAKE_CASE_		)

		lowerCamelCase   : Tuple								=HillCipher(numpy.array(SCREAMING_SNAKE_CASE_		)		)

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


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				main()

