'''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	:       Any						       =	logging.get_logger(__name__)


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





def       lowerCAmelCase					(		UpperCamelCase__				:   Optional[int]    ,					UpperCamelCase__				:   List[str]    ,					UpperCamelCase__				:   str    ,					UpperCamelCase__				:   int       ):


	"""simple docstring"""
	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:
		__UpperCAmelCase							=			TOKENIZER_CLASSES
	else:
		__UpperCAmelCase							=			{tokenizer_name: getattr(UpperCamelCase__    ,					tokenizer_name + '''Fast'''       )}

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

	for tokenizer_name in tokenizer_names:
		__UpperCAmelCase							=			TOKENIZER_CLASSES[tokenizer_name]

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

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

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

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

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


if __name__ == "__main__":
					__lowerCAmelCase	:       Dict						       =	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	:       Tuple						       =	parser.parse_args()

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






'''simple docstring'''


import requests
from bsa import BeautifulSoup





def       lowerCAmelCase					(		UpperCamelCase__				:   str = "AAPL"       ):


	"""simple docstring"""
	__UpperCAmelCase							=			f"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
	__UpperCAmelCase							=			BeautifulSoup(requests.get(UpperCamelCase__       ).text    ,					'''html.parser'''       )
	__UpperCAmelCase							=			'''My(6px) Pos(r) smartphone_Mt(6px)'''
	return soup.find('''div'''    ,					class_=class_       ).find('''span'''       ).text


if __name__ == "__main__":
					for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
										print(F"""Current {symbol:<4} stock price is {stock_price(symbol):>8}""")
