

"""simple docstring"""






import string

import numpy





def 	lowercase      (   __UpperCamelCase      ,   __UpperCamelCase						) ->      int:
 return b if a == 0 else greatest_common_divisor(b % a      ,   _SCREAMING_SNAKE_CASE						)
class        _lowercase					:
     _lowerCamelCase     =       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     =       numpy.vectorize(lambda __UpperCAmelCase     : x % 36     )

     _lowerCamelCase     =       numpy.vectorize(__UpperCAmelCase     )







     def __init__(      self ,						UpperCamelCase_       ):
      __magic_name__     =      self.modulus(UpperCamelCase_       )  # mod36 calc's on the encrypt key
      self.check_determinant()  # validate the determinant of the encryption key
      __magic_name__     =      encrypt_key.shape[0]







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      return self.key_string.index(UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      return self.key_string[round(UpperCamelCase_       )]







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      round(numpy.linalg.det(self.encrypt_key       )       )

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

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







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      __magic_name__     =      [char for char in text.upper() if char in self.key_string]

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

      return "".join(UpperCamelCase_       )







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      __magic_name__     =      self.process_text(text.upper()       )
      __magic_name__     =      ''''''

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

      return encrypted







     def 	lowerCAmelCase__    (      self       ):
      __magic_name__     =      round(numpy.linalg.det(self.encrypt_key       )       )

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

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

      return self.to_int(self.modulus(UpperCamelCase_       )       )







     def 	lowerCAmelCase__    (      self ,						UpperCamelCase_       ):
      __magic_name__     =      self.make_decrypt_key()
      __magic_name__     =      self.process_text(text.upper()       )
      __magic_name__     =      ''''''

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

      return decrypted





def 	lowercase      (   ) ->      None:
 __magic_name__     =      int(input('''Enter the order of the encryption key: '''						)						)
 __magic_name__     =      []

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

 __magic_name__     =      HillCipher(numpy.array(_SCREAMING_SNAKE_CASE						)						)

 print('''Would you like to encrypt or decrypt some text? (1 or 2)'''						)
 __magic_name__     =      input('''\n1. Encrypt\n2. Decrypt\n'''						)
 if option == "1":
  __magic_name__     =      input('''What text would you like to encrypt?: '''						)
  print('''Your encrypted text is:'''						)
  print(hc.encrypt(_SCREAMING_SNAKE_CASE						)						)
 elif option == "2":
  __magic_name__     =      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()




"""simple docstring"""






import os

import pytest
import yaml

from datasets.features.features import Features, Value
from datasets.info import DatasetInfo, DatasetInfosDict





@pytest.mark.parametrize(
    '''files'''      ,   [
        ['''full:README.md''', '''dataset_infos.json'''],
        ['''empty:README.md''', '''dataset_infos.json'''],
        ['''dataset_infos.json'''],
        ['''full:README.md'''],
    ]      ,   )
def 	lowercase      (   __UpperCamelCase      ,   __UpperCamelCase						) ->      List[str]:
 __magic_name__     =      tmp_path_factory.mktemp('''dset_infos_dir'''						)
 if "full:README.md" in files:
  with open(dataset_infos_dir / '''README.md'''      ,   '''w'''						) as f:
   f.write('''---\ndataset_info:\n  dataset_size: 42\n---'''						)
 if "empty:README.md" in files:
  with open(dataset_infos_dir / '''README.md'''      ,   '''w'''						) as f:
   f.write(''''''						)
    # we want to support dataset_infos.json for backward compatibility
 if "dataset_infos.json" in files:
  with open(dataset_infos_dir / '''dataset_infos.json'''      ,   '''w'''						) as f:
   f.write('''{"default": {"dataset_size": 42}}'''						)
 __magic_name__     =      DatasetInfosDict.from_directory(__UpperCamelCase						)
 assert dataset_infos
 assert dataset_infos["default"].dataset_size == 42





@pytest.mark.parametrize(
    '''dataset_info'''      ,   [
        DatasetInfo(),
        DatasetInfo(
            description='''foo'''      ,   features=Features({'''a''': Value('''int32'''						)}						)      ,   builder_name='''builder'''      ,   config_name='''config'''      ,   version='''1.0.0'''      ,   splits=[{'''name''': '''train'''}]      ,   download_size=42      ,   ),
    ]      ,   )
def 	lowercase      (   __UpperCamelCase      ,   __UpperCamelCase						) ->      Tuple:
 __magic_name__     =      str(__UpperCamelCase						)
 dataset_info.write_to_directory(__UpperCamelCase						)
 __magic_name__     =      DatasetInfo.from_directory(__UpperCamelCase						)
 assert dataset_info == reloaded
 assert os.path.exists(os.path.join(__UpperCamelCase      ,   '''dataset_info.json'''						)						)





def 	lowercase      (   ) ->      Any:
 __magic_name__     =      DatasetInfo(
     description='''foo'''      ,   citation='''bar'''      ,   homepage='''https://foo.bar'''      ,   license='''CC0'''      ,   features=Features({'''a''': Value('''int32'''						)}						)      ,   post_processed={}      ,   supervised_keys=()      ,   task_templates=[]      ,   builder_name='''builder'''      ,   config_name='''config'''      ,   version='''1.0.0'''      ,   splits=[{'''name''': '''train''', '''num_examples''': 42}]      ,   download_checksums={}      ,   download_size=1337      ,   post_processing_size=442      ,   dataset_size=1234      ,   size_in_bytes=1337 + 442 + 1234      ,   )
 __magic_name__     =      dataset_info._to_yaml_dict()
 assert sorted(__UpperCamelCase						) == sorted(DatasetInfo._INCLUDED_INFO_IN_YAML						)
 for key in DatasetInfo._INCLUDED_INFO_IN_YAML:
  assert key in dataset_info_yaml_dict
  assert isinstance(dataset_info_yaml_dict[key]      ,   (list, dict, int, str)						)
 __magic_name__     =      yaml.safe_dump(__UpperCamelCase						)
 __magic_name__     =      yaml.safe_load(__UpperCamelCase						)
 assert dataset_info_yaml_dict == reloaded





def 	lowercase      (   ) ->      str:
 __magic_name__     =      DatasetInfo()
 __magic_name__     =      dataset_info._to_yaml_dict()
 assert dataset_info_yaml_dict == {}





@pytest.mark.parametrize(
    '''dataset_infos_dict'''      ,   [
        DatasetInfosDict(),
        DatasetInfosDict({'''default''': DatasetInfo()}						),
        DatasetInfosDict({'''my_config_name''': DatasetInfo()}						),
        DatasetInfosDict(
            {
                '''default''': DatasetInfo(
                    description='''foo'''      ,   features=Features({'''a''': Value('''int32'''						)}						)      ,   builder_name='''builder'''      ,   config_name='''config'''      ,   version='''1.0.0'''      ,   splits=[{'''name''': '''train'''}]      ,   download_size=42      ,   )
            }						),
        DatasetInfosDict(
            {
                '''v1''': DatasetInfo(dataset_size=42						),
                '''v2''': DatasetInfo(dataset_size=1337						),
            }						),
    ]      ,   )
def 	lowercase      (   __UpperCamelCase      ,   __UpperCamelCase						) ->      str:
 __magic_name__     =      str(__UpperCamelCase						)
 dataset_infos_dict.write_to_directory(__UpperCamelCase						)
 __magic_name__     =      DatasetInfosDict.from_directory(__UpperCamelCase						)

 # the config_name of the dataset_infos_dict take over the attribute
 for config_name, dataset_info in dataset_infos_dict.items():
  __magic_name__     =      config_name
  # the yaml representation doesn't include fields like description or citation
  # so we just test that we can recover what we can from the yaml
  __magic_name__     =      DatasetInfo._from_yaml_dict(dataset_info._to_yaml_dict()						)
 assert dataset_infos_dict == reloaded

 if dataset_infos_dict:
  assert os.path.exists(os.path.join(__UpperCamelCase      ,   '''README.md'''						)						)

