




'''simple docstring'''



from __future__ import annotations
def 			SCREAMING_SNAKE_CASE_			(							__A    :			float	,					__A    :			float	,					__A    :			float  )			->			float:
   if days_between_payments <= 0:
      raise ValueError("days_between_payments must be > 0"  )
   if daily_interest_rate < 0:
      raise ValueError("daily_interest_rate must be >= 0"  )
   if principal <= 0:
      raise ValueError("principal must be > 0"  )
   return principal * daily_interest_rate * days_between_payments
def 			SCREAMING_SNAKE_CASE_			(							__A    :			float	,					__A    :			float	,					__A    :			float	,					)			->			float:
   if number_of_compounding_periods <= 0:
      raise ValueError("number_of_compounding_periods must be > 0"  )
   if nominal_annual_interest_rate_percentage < 0:
      raise ValueError("nominal_annual_interest_rate_percentage must be >= 0"  )
   if principal <= 0:
      raise ValueError("principal must be > 0"  )

   return principal * (
       (1 + nominal_annual_interest_rate_percentage) ** number_of_compounding_periods
       - 1
   )
def 			SCREAMING_SNAKE_CASE_			(							__A    :			float	,					__A    :			float	,					__A    :			float	,					)			->			float:
   if number_of_years <= 0:
      raise ValueError("number_of_years must be > 0"  )
   if nominal_annual_percentage_rate < 0:
      raise ValueError("nominal_annual_percentage_rate must be >= 0"  )
   if principal <= 0:
      raise ValueError("principal must be > 0"  )

   return compound_interest(
       __A	,					nominal_annual_percentage_rate / 3_65	,					number_of_years * 3_65  )


if __name__ == "__main__":
 import doctest

 doctest.testmod()







'''simple docstring'''



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 			SCREAMING_SNAKE_CASE_			(							__A    :			Optional[int]	,					__A    :			Tuple	,					__A    :			List[str]	,					__A    :			List[str]  )			->			List[Any]:
   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:
      _SCREAMING_SNAKE_CASE	=				TOKENIZER_CLASSES
   else:
      _SCREAMING_SNAKE_CASE	=				{tokenizer_name: getattr(__A	,					tokenizer_name + "Fast"  )}

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

   for tokenizer_name in tokenizer_names:
      _SCREAMING_SNAKE_CASE	=				TOKENIZER_CLASSES[tokenizer_name]

      _SCREAMING_SNAKE_CASE	=				True
      if checkpoint_name is None:
         _SCREAMING_SNAKE_CASE	=				list(tokenizer_class.max_model_input_sizes.keys()  )
      else:
         _SCREAMING_SNAKE_CASE	=				[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
         _SCREAMING_SNAKE_CASE	=				tokenizer_class.from_pretrained(__A	,					force_download=__A  )

         # 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:
            _SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE	=				checkpoint.split("/"  )
            _SCREAMING_SNAKE_CASE	=				os.path.join(__A	,					__A  )
         elif add_prefix:
            _SCREAMING_SNAKE_CASE	=				checkpoint
            _SCREAMING_SNAKE_CASE	=				dump_path
         else:
            _SCREAMING_SNAKE_CASE	=				None
            _SCREAMING_SNAKE_CASE	=				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]:
            _SCREAMING_SNAKE_CASE	=				list(tokenizer.pretrained_vocab_files_map.values()  )[0][checkpoint]
            _SCREAMING_SNAKE_CASE	=				file_path.split(__A  )[-1][0]
            if next_char == "/":
               _SCREAMING_SNAKE_CASE	=				os.path.join(__A	,					__A  )
               _SCREAMING_SNAKE_CASE	=				None

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

         _SCREAMING_SNAKE_CASE	=				tokenizer.save_pretrained(
             __A	,					legacy_format=__A	,					filename_prefix=__A  )
         logger.info(f"""=> File names {file_names}"""  )

         for file_name in file_names:
            if not file_name.endswith("tokenizer.json"  ):
               os.remove(__A  )
               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)

