






import string

import numpy







def      snake_case		(							UpperCAmelCase	:       Dict,						UpperCAmelCase	:       List[Any]   ):
				return b if a == 0 else greatest_common_divisor(b % a,						_SCREAMING_SNAKE_CASE   )
class      UpperCamelCase :







		"""simple docstring"""



		snake_case    =   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)
		snake_case    =   numpy.vectorize(lambda snake_case__ : x % 3_6 )

		snake_case    =   numpy.vectorize(snake_case__ )
		def __init__(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       numpy.ndarray		)    ->   None:


						'''simple docstring'''
						A	 =      self.modulus(_SCREAMING_SNAKE_CASE		)  # mod36 calc's on the encrypt key
						self.check_determinant()  # validate the determinant of the encryption key
						A	 =      encrypt_key.shape[0]
		def       A(  self		:       str						,_SCREAMING_SNAKE_CASE		:       str		)    ->   int:


						'''simple docstring'''
						return self.key_string.index(_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       Any						,_SCREAMING_SNAKE_CASE		:       int		)    ->   str:


						'''simple docstring'''
						return self.key_string[round(_SCREAMING_SNAKE_CASE		)]
		def       A(  self		:       Dict		)    ->   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(_SCREAMING_SNAKE_CASE						,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(_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       str		)    ->   str:


						'''simple docstring'''
						A	 =      [char for char in text.upper() if char in self.key_string]

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

						return "".join(_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       List[str]						,_SCREAMING_SNAKE_CASE		:       str		)    ->   str:


						'''simple docstring'''
						A	 =      self.process_text(text.upper()		)
						A	 =      ''

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

						return encrypted
		def       A(  self		:       int		)    ->   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(_SCREAMING_SNAKE_CASE		)		)







		def       A(  self		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       str		)    ->   str:


						'''simple docstring'''
						A	 =      self.make_decrypt_key()
						A	 =      self.process_text(text.upper()		)
						A	 =      ''

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

						return decrypted







def      snake_case		(							):
				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(_SCREAMING_SNAKE_CASE   ):
								A	 =      [int(_SCREAMING_SNAKE_CASE   ) for x in input().split()]
								hill_matrix.append(_SCREAMING_SNAKE_CASE   )

				A	 =      HillCipher(numpy.array(_SCREAMING_SNAKE_CASE   )   )

				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(_SCREAMING_SNAKE_CASE   )   )
				elif option == "2":
								A	 =      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()













import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType
class      UpperCamelCase (				snake_case__ ):







		"""simple docstring"""



		snake_case    =   ["image_processor", "tokenizer"]
		snake_case    =   "LayoutLMv2ImageProcessor"
		snake_case    =   ("LayoutXLMTokenizer", "LayoutXLMTokenizerFast")
		def __init__(  self		:       List[str]						,_SCREAMING_SNAKE_CASE		:       List[str]=None						,_SCREAMING_SNAKE_CASE		:       Optional[int]=None						,**_SCREAMING_SNAKE_CASE		:       Tuple		)    ->   List[str]:


						'''simple docstring'''
						if "feature_extractor" in kwargs:
										warnings.warn(
										    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
										    ' instead.'						,_SCREAMING_SNAKE_CASE						,)
										A	 =      kwargs.pop('feature_extractor'		)

						A	 =      image_processor if image_processor is not None else feature_extractor
						if image_processor is None:
										raise ValueError('You need to specify an `image_processor`.'		)
						if tokenizer is None:
										raise ValueError('You need to specify a `tokenizer`.'		)

						super().__init__(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)
		def __call__(  self		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None						,_SCREAMING_SNAKE_CASE		:       Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None						,_SCREAMING_SNAKE_CASE		:       Union[List[List[int]], List[List[List[int]]]] = None						,_SCREAMING_SNAKE_CASE		:       Optional[Union[List[int], List[List[int]]]] = None						,_SCREAMING_SNAKE_CASE		:       bool = True						,_SCREAMING_SNAKE_CASE		:       Union[bool, str, PaddingStrategy] = False						,_SCREAMING_SNAKE_CASE		:       Union[bool, str, TruncationStrategy] = None						,_SCREAMING_SNAKE_CASE		:       Optional[int] = None						,_SCREAMING_SNAKE_CASE		:       int = 0						,_SCREAMING_SNAKE_CASE		:       Optional[int] = None						,_SCREAMING_SNAKE_CASE		:       Optional[bool] = None						,_SCREAMING_SNAKE_CASE		:       Optional[bool] = None						,_SCREAMING_SNAKE_CASE		:       bool = False						,_SCREAMING_SNAKE_CASE		:       bool = False						,_SCREAMING_SNAKE_CASE		:       bool = False						,_SCREAMING_SNAKE_CASE		:       bool = False						,_SCREAMING_SNAKE_CASE		:       bool = True						,_SCREAMING_SNAKE_CASE		:       Optional[Union[str, TensorType]] = None						,**_SCREAMING_SNAKE_CASE		:       Tuple						,)    ->   BatchEncoding:


						'''simple docstring'''
						# verify input
						if self.image_processor.apply_ocr and (boxes is not None):
										raise ValueError(
										    'You cannot provide bounding boxes '
										    'if you initialized the image processor with apply_ocr set to True.'		)

						if self.image_processor.apply_ocr and (word_labels is not None):
										raise ValueError(
										    'You cannot provide word labels if you initialized the image processor with apply_ocr set to True.'		)

						if return_overflowing_tokens is True and return_offsets_mapping is False:
										raise ValueError('You cannot return overflowing tokens without returning the offsets mapping.'		)

						# first, apply the image processor
						A	 =      self.image_processor(images=_SCREAMING_SNAKE_CASE						,return_tensors=_SCREAMING_SNAKE_CASE		)

						# second, apply the tokenizer
						if text is not None and self.image_processor.apply_ocr and text_pair is None:
										if isinstance(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		):
														A	 =      [text]  # add batch dimension (as the image processor always adds a batch dimension)
										A	 =      features['words']

						A	 =      self.tokenizer(
						    text=text if text is not None else features['words']						,text_pair=text_pair if text_pair is not None else None						,boxes=boxes if boxes is not None else features['boxes']						,word_labels=_SCREAMING_SNAKE_CASE						,add_special_tokens=_SCREAMING_SNAKE_CASE						,padding=_SCREAMING_SNAKE_CASE						,truncation=_SCREAMING_SNAKE_CASE						,max_length=_SCREAMING_SNAKE_CASE						,stride=_SCREAMING_SNAKE_CASE						,pad_to_multiple_of=_SCREAMING_SNAKE_CASE						,return_token_type_ids=_SCREAMING_SNAKE_CASE						,return_attention_mask=_SCREAMING_SNAKE_CASE						,return_overflowing_tokens=_SCREAMING_SNAKE_CASE						,return_special_tokens_mask=_SCREAMING_SNAKE_CASE						,return_offsets_mapping=_SCREAMING_SNAKE_CASE						,return_length=_SCREAMING_SNAKE_CASE						,verbose=_SCREAMING_SNAKE_CASE						,return_tensors=_SCREAMING_SNAKE_CASE						,**_SCREAMING_SNAKE_CASE						,)

						# add pixel values
						A	 =      features.pop('pixel_values'		)
						if return_overflowing_tokens is True:
										A	 =      self.get_overflowing_images(_SCREAMING_SNAKE_CASE						,encoded_inputs['overflow_to_sample_mapping']		)
						A	 =      images

						return encoded_inputs
		def       A(  self		:       Dict						,_SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[Any]		)    ->   Dict:


						'''simple docstring'''
						# in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
						A	 =      []
						for sample_idx in overflow_to_sample_mapping:
										images_with_overflow.append(images[sample_idx]		)

						if len(_SCREAMING_SNAKE_CASE		) != len(_SCREAMING_SNAKE_CASE		):
										raise ValueError(
										    'Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got'
										    f' {len(_SCREAMING_SNAKE_CASE		)} and {len(_SCREAMING_SNAKE_CASE		)}'		)

						return images_with_overflow
		def       A(  self		:       List[str]						,*_SCREAMING_SNAKE_CASE		:       str						,**_SCREAMING_SNAKE_CASE		:       Union[str, Any]		)    ->   Tuple:


						'''simple docstring'''
						return self.tokenizer.batch_decode(*_SCREAMING_SNAKE_CASE						,**_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       Dict						,*_SCREAMING_SNAKE_CASE		:       Tuple						,**_SCREAMING_SNAKE_CASE		:       int		)    ->   int:


						'''simple docstring'''
						return self.tokenizer.decode(*_SCREAMING_SNAKE_CASE						,**_SCREAMING_SNAKE_CASE		)
		@property
		def       A(  self		:       Any		)    ->   Union[str, Any]:


						'''simple docstring'''
						return ["input_ids", "bbox", "attention_mask", "image"]
		@property
		def       A(  self		:       Dict		)    ->   int:


						'''simple docstring'''
						warnings.warn(
						    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'						,_SCREAMING_SNAKE_CASE						,)
						return self.image_processor_class







		@property
		def       A(  self		:       Optional[int]		)    ->   Union[str, Any]:


						'''simple docstring'''
						warnings.warn(
						    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'						,_SCREAMING_SNAKE_CASE						,)
						return self.image_processor





