





import os
import random
import sys

from . import cryptomath_module as cryptomath
from . import rabin_miller

lowerCAmelCase_						   =    3


def     lowerCamelCase_	(      lowerCAmelCase:	int				)->		int:
  print('Generating primitive root of p'				)
  while True:
    _snake_case   :				int														=	random.randrange(3    ,							lowerCAmelCase				)
    if pow(lowerCAmelCase    ,							2    ,							lowerCAmelCase				) == 1:
      continue
    if pow(lowerCAmelCase    ,							lowerCAmelCase    ,							lowerCAmelCase				) == 1:
      continue
    return g


def     lowerCamelCase_	(      lowerCAmelCase:	int				)->		tuple[tuple[int, int, int, int], tuple[int, int]]:
  print('Generating prime p...'				)
  _snake_case   :				Optional[int]														=	rabin_miller.generate_large_prime(lowerCAmelCase				)  # select large prime number.
  _snake_case   :				Tuple														=	primitive_root(lowerCAmelCase				)  # one primitive root on modulo p.
  _snake_case   :				List[str]														=	random.randrange(3    ,							lowerCAmelCase				)  # private_key -> have to be greater than 2 for safety.
  _snake_case   :				Any														=	cryptomath.find_mod_inverse(pow(lowerCAmelCase    ,							lowerCAmelCase    ,							lowerCAmelCase				)    ,							lowerCAmelCase				)

  _snake_case   :				int														=	(key_size, e_a, e_a, p)
  _snake_case   :				Tuple														=	(key_size, d)

  return public_key, private_key


def     lowerCamelCase_	(      lowerCAmelCase:	str    ,							lowerCAmelCase:	int				)->		None:
  if os.path.exists(F"""{name}_pubkey.txt"""				) or os.path.exists(F"""{name}_privkey.txt"""				):
    print('\nWARNING:'				)
    print(
        F"""\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n"""
        'Use a different name or delete these files and re-run this program.'				)
    sys.exit()

  _snake_case							,					_snake_case   :				Tuple														=	generate_key(lowerCAmelCase				)
  print(F"""\nWriting public key to file {name}_pubkey.txt..."""				)
  with open(F"""{name}_pubkey.txt"""    ,							'w'				) as fo:
    fo.write(F"""{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}"""				)

  print(F"""Writing private key to file {name}_privkey.txt..."""				)
  with open(F"""{name}_privkey.txt"""    ,							'w'				) as fo:
    fo.write(F"""{private_key[0]},{private_key[1]}"""				)


def     lowerCamelCase_	(      )->		None:
  print('Making key files...'				)
  make_key_files('elgamal'    ,							20_48				)
  print('Key files generation successful'				)


if __name__ == "__main__":
      main()











import argparse
import os

import transformers

from .convert_slow_tokenizer import SLOW_TO_FAST_CONVERTERS
from .utils import logging


logging.set_verbosity_info()

lowerCAmelCase_						   =    logging.get_logger(__name__)


lowerCAmelCase_						   =    {name: getattr(transformers, name + """Fast""") for name in SLOW_TO_FAST_CONVERTERS}


def     lowerCamelCase_	(      lowerCAmelCase:	List[Any]    ,							lowerCAmelCase:	Optional[Any]    ,							lowerCAmelCase:	Dict    ,							lowerCAmelCase:	Union[str, Any]				)->		Optional[int]:
  if tokenizer_name is not None and tokenizer_name not in TOKENIZER_CLASSES:
    raise ValueError(F"""Unrecognized tokenizer name, should be one of {list(TOKENIZER_CLASSES.keys()				)}."""				)

  if tokenizer_name is None:
    _snake_case   :				Tuple														=	TOKENIZER_CLASSES
  else:
    _snake_case   :				Union[str, Any]														=	{tokenizer_name: getattr(lowerCAmelCase    ,							tokenizer_name + 'Fast'				)}

  logger.info(F"""Loading tokenizer classes: {tokenizer_names}"""				)

  for tokenizer_name in tokenizer_names:
    _snake_case   :				Dict														=	TOKENIZER_CLASSES[tokenizer_name]

    _snake_case   :				Optional[Any]														=	True
    if checkpoint_name is None:
      _snake_case   :				Union[str, Any]														=	list(tokenizer_class.max_model_input_sizes.keys()				)
    else:
      _snake_case   :				Optional[int]														=	[checkpoint_name]

    logger.info(F"""For tokenizer {tokenizer_class.__class__.__name__} loading checkpoints: {checkpoint_names}"""				)

    for checkpoint in checkpoint_names:
      logger.info(F"""Loading {tokenizer_class.__class__.__name__} {checkpoint}"""				)

      # Load tokenizer
      _snake_case   :				str														=	tokenizer_class.from_pretrained(lowerCAmelCase    ,							force_download=lowerCAmelCase				)

      # Save fast tokenizer
      logger.info(F"""Save fast tokenizer to {dump_path} with prefix {checkpoint} add_prefix {add_prefix}"""				)

      # For organization names we create sub-directories
      if "/" in checkpoint:
        _snake_case							,					_snake_case   :				Tuple														=	checkpoint.split('/'				)
        _snake_case   :				int														=	os.path.join(lowerCAmelCase    ,							lowerCAmelCase				)
      elif add_prefix:
        _snake_case   :				Dict														=	checkpoint
        _snake_case   :				Optional[Any]														=	dump_path
      else:
        _snake_case   :				str														=	None
        _snake_case   :				Union[str, Any]														=	dump_path

      logger.info(F"""=> {dump_path_full} with prefix {checkpoint_prefix_name}, add_prefix {add_prefix}"""				)

      if checkpoint in list(tokenizer.pretrained_vocab_files_map.values()				)[0]:
        _snake_case   :				Optional[Any]														=	list(tokenizer.pretrained_vocab_files_map.values()				)[0][checkpoint]
        _snake_case   :				Optional[int]														=	file_path.split(lowerCAmelCase				)[-1][0]
        if next_char == "/":
          _snake_case   :				Union[str, Any]														=	os.path.join(lowerCAmelCase    ,							lowerCAmelCase				)
          _snake_case   :				str														=	None

        logger.info(F"""=> {dump_path_full} with prefix {checkpoint_prefix_name}, add_prefix {add_prefix}"""				)

      _snake_case   :				Optional[int]														=	tokenizer.save_pretrained(
          lowerCAmelCase    ,							legacy_format=lowerCAmelCase    ,							filename_prefix=lowerCAmelCase				)
      logger.info(F"""=> File names {file_names}"""				)

      for file_name in file_names:
        if not file_name.endswith('tokenizer.json'				):
          os.remove(lowerCAmelCase				)
          logger.info(F"""=> removing {file_name}"""				)


if __name__ == "__main__":
      lowerCAmelCase_						   =    argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--dump_path""", default=None, type=str, required=True, help="""Path to output generated fast tokenizer files."""
      )
      parser.add_argument(
          """--tokenizer_name""",
          default=None,
          type=str,
          help=(
              F"""Optional tokenizer type selected in the list of {list(TOKENIZER_CLASSES.keys())}. If not given, will """
              """download and convert all the checkpoints from AWS."""
          ),
      )
      parser.add_argument(
          """--checkpoint_name""",
          default=None,
          type=str,
          help="""Optional checkpoint name. If not given, will download and convert the canonical checkpoints from AWS.""",
      )
      parser.add_argument(
          """--force_download""",
          action="""store_true""",
          help="""Re-download checkpoints.""",
      )
      lowerCAmelCase_						   =    parser.parse_args()

      convert_slow_checkpoint_to_fast(args.tokenizer_name, args.checkpoint_name, args.dump_path, args.force_download)




