import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


lowerCAmelCase__      		=					datasets.utils.logging.get_logger(__name__)
@dataclass
class 							a_					(		datasets.BuilderConfig		):






 '''simple docstring'''






 UpperCAmelCase_      					=   None






class 							a_					(		datasets.ArrowBasedBuilder		):






 '''simple docstring'''






 UpperCAmelCase_      					=   ArrowConfig




 def 						__snake_case		(     self   :    List[Any]):







        '''simple docstring'''



        return datasets.DatasetInfo(features=self.config.features)




 def 						__snake_case		(     self   :    Dict     ,       lowercase__   :    Optional[Any]):







        '''simple docstring'''



        if not self.config.data_files:
               raise ValueError(F"""At least one data file must be specified, but got data_files={self.config.data_files}""")
        lowerCAmelCase__	      =   dl_manager.download_and_extract(self.config.data_files)
        if isinstance(lowercase__     ,       (str, list, tuple)):
               lowerCAmelCase__	      =   data_files
               if isinstance(lowercase__     ,       lowercase__):
                      lowerCAmelCase__	      =   [files]
               # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
               lowerCAmelCase__	      =   [dl_manager.iter_files(lowercase__) for file in files]
               return [datasets.SplitGenerator(name=datasets.Split.TRAIN     ,       gen_kwargs={'files': files})]
        lowerCAmelCase__	      =   []
        for split_name, files in data_files.items():
               if isinstance(lowercase__     ,       lowercase__):
                      lowerCAmelCase__	      =   [files]
               # Use `dl_manager.iter_files` to skip hidden files in an extracted archive
               lowerCAmelCase__	      =   [dl_manager.iter_files(lowercase__) for file in files]
               # Infer features is they are stoed in the arrow schema
               if self.info.features is None:
                      for file in itertools.chain.from_iterable(lowercase__):
                             with open(lowercase__     ,       'rb') as f:
                                    lowerCAmelCase__	      =   datasets.Features.from_arrow_schema(pa.ipc.open_stream(lowercase__).schema)
                             break
               splits.append(datasets.SplitGenerator(name=lowercase__     ,       gen_kwargs={'files': files}))
        return splits




 def 						__snake_case		(     self   :    str     ,       lowercase__   :    pa.Table):







        '''simple docstring'''



        if self.info.features is not None:
               # more expensive cast to support nested features with keys in a different order
               # allows str <-> int/float or str to Audio for example
               lowerCAmelCase__	      =   table_cast(lowercase__     ,       self.info.features.arrow_schema)
        return pa_table




 def 						__snake_case		(     self   :    Tuple     ,       lowercase__   :    Optional[Any]):







        '''simple docstring'''



        for file_idx, file in enumerate(itertools.chain.from_iterable(lowercase__)):
               with open(lowercase__     ,       'rb') as f:
                      try:
                             for batch_idx, record_batch in enumerate(pa.ipc.open_stream(lowercase__)):
                                    lowerCAmelCase__	      =   pa.Table.from_batches([record_batch])
                                    # Uncomment for debugging (will print the Arrow table size and elements)
                                    # logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
                                    # logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
                                    yield F"""{file_idx}_{batch_idx}""", self._cast_table(lowercase__)
                      except ValueError as e:
                             logger.error(F"""Failed to read file '{file}' with error {type(lowercase__)}: {e}""")
                             raise

import random
import sys

from . import cryptomath_module as cryptomath

lowerCAmelCase__      		=					(
    r' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`'
    r'abcdefghijklmnopqrstuvwxyz{|}~'
)






def  __lowerCamelCase						(		lowerCAmelCase__      ,    lowerCAmelCase__      ,    lowerCAmelCase__      ):
       if mode == "encrypt":
              if key_a == 1:
                     sys.exit(
                         'The affine cipher becomes weak when key '
                         'A is set to 1. Choose different key'      )
              if key_b == 0:
                     sys.exit(
                         'The affine cipher becomes weak when key '
                         'B is set to 0. Choose different key'      )
       if key_a < 0 or key_b < 0 or key_b > len(lowerCAmelCase__      ) - 1:
              sys.exit(
                  'Key A must be greater than 0 and key B must '
                  F"""be between 0 and {len(lowerCAmelCase__      ) - 1}."""      )
       if cryptomath.gcd(lowerCAmelCase__      ,    len(lowerCAmelCase__      )      ) != 1:
              sys.exit(
                  F"""Key A {key_a} and the symbol set size {len(lowerCAmelCase__      )} """
                  'are not relatively prime. Choose a different key.'      )






def  __lowerCamelCase						(		lowerCAmelCase__      ,    lowerCAmelCase__      ):
       lowerCAmelCase__      ,   lowerCAmelCase__	      =   divmod(lowerCAmelCase__      ,    len(lowerCAmelCase__      )      )
       check_keys(lowerCAmelCase__      ,    lowerCAmelCase__      ,    'encrypt'      )
       lowerCAmelCase__	      =   ''
       for symbol in message:
              if symbol in SYMBOLS:
                     lowerCAmelCase__	      =   SYMBOLS.find(lowerCAmelCase__      )
                     cipher_text += SYMBOLS[(sym_index * key_a + key_b) % len(lowerCAmelCase__      )]
              else:
                     cipher_text += symbol
       return cipher_text






def  __lowerCamelCase						(		lowerCAmelCase__      ,    lowerCAmelCase__      ):
       lowerCAmelCase__      ,   lowerCAmelCase__	      =   divmod(lowerCAmelCase__      ,    len(lowerCAmelCase__      )      )
       check_keys(lowerCAmelCase__      ,    lowerCAmelCase__      ,    'decrypt'      )
       lowerCAmelCase__	      =   ''
       lowerCAmelCase__	      =   cryptomath.find_mod_inverse(lowerCAmelCase__      ,    len(lowerCAmelCase__      )      )
       for symbol in message:
              if symbol in SYMBOLS:
                     lowerCAmelCase__	      =   SYMBOLS.find(lowerCAmelCase__      )
                     plain_text += SYMBOLS[
                         (sym_index - key_b) * mod_inverse_of_key_a % len(lowerCAmelCase__      )
                     ]
              else:
                     plain_text += symbol
       return plain_text






def  __lowerCamelCase						(		):
       while True:
              lowerCAmelCase__	      =   random.randint(2      ,    len(lowerCAmelCase__      )      )
              lowerCAmelCase__	      =   random.randint(2      ,    len(lowerCAmelCase__      )      )
              if cryptomath.gcd(lowerCAmelCase__      ,    len(lowerCAmelCase__      )      ) == 1 and key_b % len(lowerCAmelCase__      ) != 0:
                     return key_b * len(lowerCAmelCase__      ) + key_b






def  __lowerCamelCase						(		):
       lowerCAmelCase__	      =   input('Enter message: '      ).strip()
       lowerCAmelCase__	      =   int(input('Enter key [2000 - 9000]: '      ).strip()      )
       lowerCAmelCase__	      =   input('Encrypt/Decrypt [E/D]: '      ).strip().lower()

       if mode.startswith('e'      ):
              lowerCAmelCase__	      =   'encrypt'
              lowerCAmelCase__	      =   encrypt_message(lowerCAmelCase__      ,    lowerCAmelCase__      )
       elif mode.startswith('d'      ):
              lowerCAmelCase__	      =   'decrypt'
              lowerCAmelCase__	      =   decrypt_message(lowerCAmelCase__      ,    lowerCAmelCase__      )
       print(F"""\n{mode.title()}ed text: \n{translated}"""      )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    # main()
