




import string

import numpy
def 		snake_case_   (UpperCamelCase	:  Any			,						UpperCamelCase	:  int				):





							'''simple docstring'''


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

class       A   :
							lowercase_          =    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_          =    numpy.vectorize(lambda _a   : x % 36   )

							lowercase_          =    numpy.vectorize(_a   )







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


														"""simple docstring"""


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







							def        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  str )      ->							int:


														"""simple docstring"""


														return self.key_string.index(__A )







							def        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  int )      ->							str:


														"""simple docstring"""


														return self.key_string[round(__A )]







							def        __lowerCAmelCase      (  self	:  int )      ->							None:


														"""simple docstring"""


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

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

														_a     					=    len(self.key_string )
														if greatest_common_divisor(__A							,      len(self.key_string ) ) != 1:
																					_a     					=    (
																					    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        __lowerCAmelCase      (  self	:  Union[str, Any]							,      lowerCAmelCase_	:  str )      ->							str:


														"""simple docstring"""


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

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

														return "".join(__A )







							def        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  str )      ->							str:


														"""simple docstring"""


														_a     					=    self.process_text(text.upper() )
														_a     					=    ''''''

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

														return encrypted







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							numpy.ndarray:


														"""simple docstring"""


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

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

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

														return self.to_int(self.modulus(__A ) )







							def        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  str )      ->							str:


														"""simple docstring"""


														_a     					=    self.make_decrypt_key()
														_a     					=    self.process_text(text.upper() )
														_a     					=    ''''''

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

														return decrypted



def 		snake_case_   ():





							'''simple docstring'''


							_a     					=    int(input('''Enter the order of the encryption key: '''				)				)
							_a     					=    []

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

							_a     					=    HillCipher(numpy.array(_lowercase				)				)

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


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				main()







'''simple docstring'''


import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


_snake_case				:				int       							=		get_tests_dir('fixtures')
_snake_case				:				Tuple       							=		get_tests_dir('fixtures/dummy_feature_extractor_config.json')
_snake_case				:				Optional[int]       							=		get_tests_dir('fixtures/dummy-config.json')

class       A   (		unittest.TestCase   ):







							def        __lowerCAmelCase      (  self	:  int )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    0







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							int:


														"""simple docstring"""


														_a     					=    AutoFeatureExtractor.from_pretrained('''facebook/wav2vec2-base-960h''' )
														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  str )      ->							Tuple:


														"""simple docstring"""


														_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )
														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







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


														"""simple docstring"""


														with tempfile.TemporaryDirectory() as tmpdirname:
																					_a     					=    WavaVecaConfig()

																					# remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ ).to_dict()

																					config_dict.pop('''feature_extractor_type''' )
																					_a     					=    WavaVecaFeatureExtractor(**lowerCAmelCase_ )

																					# save in new folder
																					model_config.save_pretrained(lowerCAmelCase_ )
																					config.save_pretrained(lowerCAmelCase_ )

																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )

																					# make sure private variable is not incorrectly saved
																					_a     					=    json.loads(config.to_json_string() )
																					self.assertTrue('''_processor_class''' not in dict_as_saved )

														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







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


														"""simple docstring"""


														_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )
														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							str:


														"""simple docstring"""


														with self.assertRaisesRegex(
														    lowerCAmelCase_							,      '''bert-base is not a local folder and is not a valid model identifier''' ):
																					_a     					=    AutoFeatureExtractor.from_pretrained('''bert-base''' )







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


														"""simple docstring"""


														with self.assertRaisesRegex(
														    lowerCAmelCase_							,      R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)''' ):
																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_							,      revision='''aaaaaa''' )







							def        __lowerCAmelCase      (  self	:  Any )      ->							Dict:


														"""simple docstring"""


														with self.assertRaisesRegex(
														    lowerCAmelCase_							,      '''hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'''							,      ):
																					_a     					=    AutoFeatureExtractor.from_pretrained('''hf-internal-testing/config-no-model''' )







							def        __lowerCAmelCase      (  self	:  List[Any] )      ->							Any:


														"""simple docstring"""


														with self.assertRaises(lowerCAmelCase_ ):
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor''' )
														# If remote code is disabled, we can't load this config.
														with self.assertRaises(lowerCAmelCase_ ):
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )

														_a     					=    AutoFeatureExtractor.from_pretrained(
														    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )
														self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )

														# Test feature extractor can be reloaded.
														with tempfile.TemporaryDirectory() as tmp_dir:
																					feature_extractor.save_pretrained(lowerCAmelCase_ )
																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_							,      trust_remote_code=lowerCAmelCase_ )
														self.assertEqual(reloaded_feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )







							def        __lowerCAmelCase      (  self	:  int )      ->							Optional[Any]:


														"""simple docstring"""


														try:
																					AutoConfig.register('''custom'''							,      lowerCAmelCase_ )
																					AutoFeatureExtractor.register(lowerCAmelCase_							,      lowerCAmelCase_ )
																					# Trying to register something existing in the Transformers library will raise an error
																					with self.assertRaises(lowerCAmelCase_ ):
																												AutoFeatureExtractor.register(lowerCAmelCase_							,      lowerCAmelCase_ )

																					# Now that the config is registered, it can be used as any other config with the auto-API
																					_a     					=    CustomFeatureExtractor.from_pretrained(lowerCAmelCase_ )
																					with tempfile.TemporaryDirectory() as tmp_dir:
																												feature_extractor.save_pretrained(lowerCAmelCase_ )
																												_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )
																												self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )

														finally:
																					if "custom" in CONFIG_MAPPING._extra_content:
																												del CONFIG_MAPPING._extra_content["custom"]
																					if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
																												del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Any:


														"""simple docstring"""


														class       A   (		_a   ):
																					lowercase_          =    True

														try:
																					AutoConfig.register('''custom'''							,      lowerCAmelCase_ )
																					AutoFeatureExtractor.register(lowerCAmelCase_							,      lowerCAmelCase_ )
																					# If remote code is not set, the default is to use local
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor''' )
																					self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )
																					self.assertTrue(feature_extractor.is_local )

																					# If remote code is disabled, we load the local one.
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )
																					self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )
																					self.assertTrue(feature_extractor.is_local )

																					# If remote is enabled, we load from the Hub
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )
																					self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )
																					self.assertTrue(not hasattr(lowerCAmelCase_							,      '''is_local''' ) )

														finally:
																					if "custom" in CONFIG_MAPPING._extra_content:
																												del CONFIG_MAPPING._extra_content["custom"]
																					if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
																												del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]

