



"""simple docstring"""







import os
import sys

from . import rsa_key_generator as rkg

UpperCAmelCase:  int			     =				128
UpperCAmelCase:  Dict			     =				256


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase   ,				__UpperCAmelCase = DEFAULT_BLOCK_SIZE      ):
		_lowercase				: Any     =   message.encode("""ascii"""      )

		_lowercase				: Dict     =   []
		for block_start in range(0   ,				len(__UpperCAmelCase      )   ,				__UpperCAmelCase      ):
				_lowercase				: int     =   0
				for i in range(__UpperCAmelCase   ,				min(block_start + block_size   ,				len(__UpperCAmelCase      )      )      ):
						block_int += message_bytes[i] * (BYTE_SIZE ** (i % block_size))
				block_ints.append(__UpperCAmelCase      )
		return block_ints


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase = DEFAULT_BLOCK_SIZE      ):
		_lowercase				: list[str]     =   []
		for block_int in block_ints:
				_lowercase				: list[str]     =   []
				for i in range(block_size - 1   ,				-1   ,				-1      ):
						if len(__UpperCAmelCase      ) + i < message_length:
								_lowercase				: Optional[int]     =   block_int // (BYTE_SIZE**i)
								_lowercase				: List[Any]     =   block_int % (BYTE_SIZE**i)
								block_message.insert(0   ,				chr(__UpperCAmelCase      )      )
				message.extend(__UpperCAmelCase      )
		return "".join(__UpperCAmelCase      )


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase = DEFAULT_BLOCK_SIZE      ):
		_lowercase				: int     =   []
		_lowercase     ,  _lowercase				: List[Any]     =   key

		for block in get_blocks_from_text(__UpperCAmelCase   ,				__UpperCAmelCase      ):
				encrypted_blocks.append(pow(__UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase      )      )
		return encrypted_blocks


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase = DEFAULT_BLOCK_SIZE   ,				):
		_lowercase				: Tuple     =   []
		_lowercase     ,  _lowercase				: Optional[int]     =   key
		for block in encrypted_blocks:
				decrypted_blocks.append(pow(__UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase      )      )
		return get_text_from_blocks(__UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase      )


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase      ):
		with open(__UpperCAmelCase      ) as fo:
				_lowercase				: Optional[Any]     =   fo.read()
		_lowercase     ,  _lowercase     ,  _lowercase				: Optional[Any]     =   content.split(""","""      )
		return (int(__UpperCAmelCase      ), int(__UpperCAmelCase      ), int(__UpperCAmelCase      ))


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase = DEFAULT_BLOCK_SIZE   ,				):
		_lowercase     ,  _lowercase     ,  _lowercase				: Optional[Any]     =   read_key_file(__UpperCAmelCase      )
		if key_size < block_size * 8:
				sys.exit(
				    """ERROR: Block size is {} bits and key size is {} bits. The RSA cipher """
				    """requires the block size to be equal to or greater than the key size. """
				    """Either decrease the block size or use different keys.""".format(
				        block_size * 8   ,				__UpperCAmelCase      )      )

		_lowercase				: str     =   [str(__UpperCAmelCase      ) for i in encrypt_message(__UpperCAmelCase   ,				(n, e)   ,				__UpperCAmelCase      )]

		_lowercase				: List[str]     =   """,""".join(__UpperCAmelCase      )
		_lowercase				: List[Any]     =   F"""{len(__UpperCAmelCase      )}_{block_size}_{encrypted_content}"""
		with open(__UpperCAmelCase   ,				"""w"""      ) as fo:
				fo.write(__UpperCAmelCase      )
		return encrypted_content


def  __SCREAMING_SNAKE_CASE (  __UpperCAmelCase   ,				__UpperCAmelCase      ):
		_lowercase     ,  _lowercase     ,  _lowercase				: List[Any]     =   read_key_file(__UpperCAmelCase      )
		with open(__UpperCAmelCase      ) as fo:
				_lowercase				: List[Any]     =   fo.read()
		_lowercase     ,  _lowercase     ,  _lowercase				: int     =   content.split("""_"""      )
		_lowercase				: Union[str, Any]     =   int(__UpperCAmelCase      )
		_lowercase				: Union[str, Any]     =   int(__UpperCAmelCase      )

		if key_size < block_size * 8:
				sys.exit(
				    """ERROR: Block size is {} bits and key size is {} bits. The RSA cipher """
				    """requires the block size to be equal to or greater than the key size. """
				    """Did you specify the correct key file and encrypted file?""".format(
				        block_size * 8   ,				__UpperCAmelCase      )      )

		_lowercase				: Any     =   []
		for block in encrypted_message.split(""","""      ):
				encrypted_blocks.append(int(__UpperCAmelCase      )      )

		return decrypt_message(__UpperCAmelCase   ,				__UpperCAmelCase   ,				(n, d)   ,				__UpperCAmelCase      )


def  __SCREAMING_SNAKE_CASE (  ):
		_lowercase				: Optional[int]     =   """encrypted_file.txt"""
		_lowercase				: Tuple     =   input(R"""Encrypt\Decrypt [e\d]: """      )

		if response.lower().startswith("""e"""      ):
				_lowercase				: Union[str, Any]     =   """encrypt"""
		elif response.lower().startswith("""d"""      ):
				_lowercase				: Any     =   """decrypt"""

		if mode == "encrypt":
				if not os.path.exists("""rsa_pubkey.txt"""      ):
						rkg.make_key_files("""rsa"""   ,				1024      )

				_lowercase				: Optional[int]     =   input("""\nEnter message: """      )
				_lowercase				: Any     =   """rsa_pubkey.txt"""
				print(F"""Encrypting and writing to {filename}..."""      )
				_lowercase				: Optional[int]     =   encrypt_and_write_to_file(__UpperCAmelCase   ,				__UpperCAmelCase   ,				__UpperCAmelCase      )

				print("""\nEncrypted text:"""      )
				print(__UpperCAmelCase      )

		elif mode == "decrypt":
				_lowercase				: Any     =   """rsa_privkey.txt"""
				print(F"""Reading from {filename} and decrypting..."""      )
				_lowercase				: List[str]     =   read_from_file_and_decrypt(__UpperCAmelCase   ,				__UpperCAmelCase      )
				print("""writing decryption to rsa_decryption.txt..."""      )
				with open("""rsa_decryption.txt"""   ,				"""w"""      ) as dec:
						dec.write(__UpperCAmelCase      )

				print("""\nDecryption:"""      )
				print(__UpperCAmelCase      )


if __name__ == "__main__":
		main()









"""simple docstring"""
import platform
from argparse import ArgumentParser

import huggingface_hub
import pandas
import pyarrow

from datasets import __version__ as version
from datasets.commands import BaseDatasetsCLICommand






def 				__lowerCAmelCase					(					__lowerCAmelCase			:		Union[str, Any]						)    ->       int:
 return EnvironmentCommand()







class  _SCREAMING_SNAKE_CASE       (     SCREAMING_SNAKE_CASE__				):



 '''simple docstring'''





 @staticmethod
 def lowercase_      (lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	Optional[Any]					      =  parser.add_parser("env"					,     help="Print relevant system environment info."   )
  download_parser.set_defaults(func=lowerCAmelCase__   )






 def lowercase_      (self   ):

  '''simple docstring'''







  _UpperCamelCase      :	Any					      =  {
      "`datasets` version": version,
      "Platform": platform.platform(),
      "Python version": platform.python_version(),
      "Huggingface_hub version": huggingface_hub.__version__,
      "PyArrow version": pyarrow.__version__,
      "Pandas version": pandas.__version__,
  }

  print("\nCopy-and-paste the text below in your GitHub issue.\n"   )
  print(self.format_dict(lowerCAmelCase__   )   )

  return info






 @staticmethod
 def lowercase_      (lowerCAmelCase__   ):

  '''simple docstring'''







  return "\n".join([F"- {prop}: {val}" for prop, val in d.items()]   ) + "\n"



