



import argparse
import os

import transformers

from .convert_slow_tokenizer import SLOW_TO_FAST_CONVERTERS
from .utils import logging


logging.set_verbosity_info()

UpperCAmelCase__     = logging.get_logger(__name__)


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





def 							A			(  _UpperCAmelCase       :     int							,     _UpperCAmelCase       :     Tuple							,     _UpperCAmelCase       :     Optional[int]							,     _UpperCAmelCase       :     List[str]					)       ->				List[str]:







			'''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__":
							UpperCAmelCase__     = 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.",
							)
							UpperCAmelCase__     = parser.parse_args()

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





import qiskit





def 							A			(  _UpperCAmelCase       :     int							,     _UpperCAmelCase       :     int					)       ->				qiskit.result.counts.Counts:







			'''simple docstring'''
			_UpperCAmelCase	 =     qiskit.Aer.get_backend('aer_simulator'					)

			# Create a Quantum Circuit acting on the q register
			_UpperCAmelCase	 =     qiskit.QuantumCircuit(_UpperCAmelCase							,     _UpperCAmelCase					)

			# Apply X (NOT) Gate to Qubits 0 & 1
			circuit.x(0					)
			circuit.x(1					)

			# Map the quantum measurement to the classical bits
			circuit.measure([0, 1]							,     [0, 1]					)

			# Execute the circuit on the qasm simulator
			_UpperCAmelCase	 =     qiskit.execute(_UpperCAmelCase							,     _UpperCAmelCase							,     shots=1_000					)

			# Return the histogram data of the results of the experiment.
			return job.result().get_counts(_UpperCAmelCase					)


if __name__ == "__main__":
							UpperCAmelCase__     = single_qubit_measure(2, 2)
							print(f"""Total count for various states are: {counts}""")
