


import argparse
import os

import evaluate
import torch
from datasets import load_dataset
from torch.optim import AdamW
from torch.utils.data import DataLoader
from transformers import AutoModelForSequenceClassification, AutoTokenizer, get_linear_schedule_with_warmup, set_seed

from accelerate import Accelerator, DistributedType


########################################################################
# This is a fully working simple example to use Accelerate
#
# This example trains a Bert base model on GLUE MRPC
# in any of the following settings (with the same script):
#   - single CPU or single GPU
#   - multi GPUS (using PyTorch distributed mode)
#   - (multi) TPUs
#   - fp16 (mixed-precision) or fp32 (normal precision)
#
# This example also demonstrates the checkpointing and sharding capabilities
#
# To run it in each of these various modes, follow the instructions
# in the readme for examples:
# https://github.com/huggingface/accelerate/tree/main/examples
#
########################################################################


_lowerCAmelCase:	str      							=					16
_lowerCAmelCase:	int      							=					32






def      _lowercase(				__a							:	Optional[int]						,    __a							:	Tuple    ):
							# Initialize accelerator
							if args.with_tracking:
														a__     						=Accelerator(
														    cpu=args.cpu						,    mixed_precision=args.mixed_precision						,    log_with='all'						,    project_dir=args.project_dir    )
							else:
														a__     						=Accelerator(cpu=args.cpu						,    mixed_precision=args.mixed_precision    )

							if hasattr(args.checkpointing_steps						,    'isdigit'    ):
														if args.checkpointing_steps == "epoch":
																					a__     						=args.checkpointing_steps
														elif args.checkpointing_steps.isdigit():
																					a__     						=int(args.checkpointing_steps    )
														else:
																					raise ValueError(
																					    f"""Argument `checkpointing_steps` must be either a number or `epoch`. `{args.checkpointing_steps}` passed."""    )
							else:
														a__     						=None
							# Sample hyper-parameters for learning rate, batch size, seed and a few other HPs
							a__     						=config['lr']
							a__     						=int(config['num_epochs']    )
							a__     						=int(config['seed']    )
							a__     						=int(config['batch_size']    )

							# We need to initialize the trackers we use, and also store our configuration
							if args.with_tracking:
														a__     						=os.path.split(__a    )[-1].split('.'    )[0]
														accelerator.init_trackers(__a						,    __a    )

							a__     						=AutoTokenizer.from_pretrained('bert-base-cased'    )
							a__     						=load_dataset('glue'						,    'mrpc'    )
							a__     						=evaluate.load('glue'						,    'mrpc'    )

							def tokenize_function(__a							:	Dict    ):
														# max_length=None => use the model max length (it's actually the default)
														a__     						=tokenizer(examples['sentence1']						,    examples['sentence2']						,    truncation=__a						,    max_length=__a    )
														return outputs

							# Apply the method we just defined to all the examples in all the splits of the dataset
							# starting with the main process first:
							with accelerator.main_process_first():
														a__     						=datasets.map(
														    __a						,    batched=__a						,    remove_columns=['idx', 'sentence1', 'sentence2']						,    )

							# We also rename the 'label' column to 'labels' which is the expected name for labels by the models of the
							# transformers library
							a__     						=tokenized_datasets.rename_column('label'						,    'labels'    )

							# If the batch size is too big we use gradient accumulation
							a__     						=1
							if batch_size > MAX_GPU_BATCH_SIZE and accelerator.distributed_type != DistributedType.TPU:
														a__     						=batch_size // MAX_GPU_BATCH_SIZE
														a__     						=MAX_GPU_BATCH_SIZE

							def collate_fn(__a							:	Optional[Any]    ):
														# On TPU it's best to pad everything to the same length or training will be very slow.
														a__     						=128 if accelerator.distributed_type == DistributedType.TPU else None
														# When using mixed precision we want round multiples of 8/16
														if accelerator.mixed_precision == "fp8":
																					a__     						=16
														elif accelerator.mixed_precision != "no":
																					a__     						=8
														else:
																					a__     						=None

														return tokenizer.pad(
														    __a						,    padding='longest'						,    max_length=__a						,    pad_to_multiple_of=__a						,    return_tensors='pt'						,    )

							# Instantiate dataloaders.
							a__     						=DataLoader(
							    tokenized_datasets['train']						,    shuffle=__a						,    collate_fn=__a						,    batch_size=__a    )
							a__     						=DataLoader(
							    tokenized_datasets['validation']						,    shuffle=__a						,    collate_fn=__a						,    batch_size=__a    )

							set_seed(__a    )

							# Instantiate the model (we build the model here so that the seed also control new weights initialization)
							a__     						=AutoModelForSequenceClassification.from_pretrained('bert-base-cased'						,    return_dict=__a    )

							# We could avoid this line since the accelerator is set with `device_placement=True` (default value).
							# Note that if you are placing tensors on devices manually, this line absolutely needs to be before the optimizer
							# creation otherwise training will not work on TPU (`accelerate` will kindly throw an error to make us aware of that).
							a__     						=model.to(accelerator.device    )

							# Instantiate optimizer
							a__     						=AdamW(params=model.parameters()						,    lr=__a    )

							# Instantiate scheduler
							a__     						=get_linear_schedule_with_warmup(
							    optimizer=__a						,    num_warmup_steps=100						,    num_training_steps=(len(__a    ) * num_epochs) // gradient_accumulation_steps						,    )

							# Prepare everything
							# There is no specific order to remember, we just need to unpack the objects in the same order we gave them to the
							# prepare method.
							a__						,    a__						,    a__						,    a__						,    a__     						=accelerator.prepare(
							    __a						,    __a						,    __a						,    __a						,    __a    )

							# We need to keep track of how many total steps we have iterated over
							a__     						=0
							# We also need to keep track of the stating epoch so files are named properly
							a__     						=0

							# Potentially load in the weights and states from a previous save
							if args.resume_from_checkpoint:
														if args.resume_from_checkpoint is not None or args.resume_from_checkpoint != "":
																					accelerator.print(f"""Resumed from checkpoint: {args.resume_from_checkpoint}"""    )
																					accelerator.load_state(args.resume_from_checkpoint    )
																					a__     						=os.path.basename(args.resume_from_checkpoint    )
														else:
																					# Get the most recent checkpoint
																					a__     						=[f.name for f in os.scandir(os.getcwd()    ) if f.is_dir()]
																					dirs.sort(key=os.path.getctime    )
																					a__     						=dirs[-1]  # Sorts folders by date modified, most recent checkpoint is the last
														# Extract `epoch_{i}` or `step_{i}`
														a__     						=os.path.splitext(__a    )[0]

														if "epoch" in training_difference:
																					a__     						=int(training_difference.replace('epoch_'						,    ''    )    ) + 1
																					a__     						=None
														else:
																					a__     						=int(training_difference.replace('step_'						,    ''    )    )
																					a__     						=resume_step // len(__a    )
																					resume_step -= starting_epoch * len(__a    )

    # Now we train the model
							for epoch in range(__a						,    __a    ):
														model.train()
														if args.with_tracking:
																					a__     						=0
														if args.resume_from_checkpoint and epoch == starting_epoch and resume_step is not None:
																					# We need to skip steps until we reach the resumed step
																					a__     						=accelerator.skip_first_batches(__a						,    __a    )
																					overall_step += resume_step
														else:
																					# After the first iteration though, we need to go back to the original dataloader
																					a__     						=train_dataloader
														for step, batch in enumerate(__a    ):
																					# We could avoid this line since we set the accelerator with `device_placement=True`.
																					batch.to(accelerator.device    )
																					a__     						=model(**__a    )
																					a__     						=outputs.loss
																					a__     						=loss / gradient_accumulation_steps
																					# We keep track of the loss at each epoch
																					if args.with_tracking:
																												total_loss += loss.detach().float()
																					accelerator.backward(__a    )
																					if step % gradient_accumulation_steps == 0:
																												optimizer.step()
																												lr_scheduler.step()
																												optimizer.zero_grad()

																					overall_step += 1

																					if isinstance(__a						,    __a    ):
																												a__     						=f"""step_{overall_step}"""
																												if overall_step % checkpointing_steps == 0:
																																			if args.output_dir is not None:
																																										a__     						=os.path.join(args.output_dir						,    __a    )
																																			accelerator.save_state(__a    )

														model.eval()
														for step, batch in enumerate(__a    ):
																					# We could avoid this line since we set the accelerator with `device_placement=True`.
																					batch.to(accelerator.device    )
																					with torch.no_grad():
																												a__     						=model(**__a    )
																					a__     						=outputs.logits.argmax(dim=-1    )
																					a__						,    a__     						=accelerator.gather_for_metrics((predictions, batch['labels'])    )
																					metric.add_batch(
																					    predictions=__a						,    references=__a						,    )

														a__     						=metric.compute()
														# Use accelerator.print to print only on the main process.
														accelerator.print(f"""epoch {epoch}:"""						,    __a    )
														if args.with_tracking:
																					accelerator.log(
																					    {
																					        'accuracy': eval_metric['accuracy'],
																					        'f1': eval_metric['f1'],
																					        'train_loss': total_loss.item() / len(__a    ),
																					        'epoch': epoch,
																					    }						,    step=__a						,    )

														if checkpointing_steps == "epoch":
																					a__     						=f"""epoch_{epoch}"""
																					if args.output_dir is not None:
																												a__     						=os.path.join(args.output_dir						,    __a    )
																					accelerator.save_state(__a    )

							if args.with_tracking:
														accelerator.end_training()






def      _lowercase(				):
							a__     						=argparse.ArgumentParser(description='Simple example of training script.'    )
							parser.add_argument(
							    '--mixed_precision'						,    type=__a						,    default=__a						,    choices=['no', 'fp16', 'bf16', 'fp8']						,    help='Whether to use mixed precision. Choose'
							    'between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10.'
							    'and an Nvidia Ampere GPU.'						,    )
							parser.add_argument('--cpu'						,    action='store_true'						,    help='If passed, will train on the CPU.'    )
							parser.add_argument(
							    '--checkpointing_steps'						,    type=__a						,    default=__a						,    help='Whether the various states should be saved at the end of every n steps, or \'epoch\' for each epoch.'						,    )
							parser.add_argument(
							    '--resume_from_checkpoint'						,    type=__a						,    default=__a						,    help='If the training should continue from a checkpoint folder.'						,    )
							parser.add_argument(
							    '--with_tracking'						,    action='store_true'						,    help='Whether to load in all available experiment trackers from the environment and use them for logging.'						,    )
							parser.add_argument(
							    '--output_dir'						,    type=__a						,    default='.'						,    help='Optional save directory where all checkpoint folders will be stored. Default is the current working directory.'						,    )
							parser.add_argument(
							    '--project_dir'						,    type=__a						,    default='logs'						,    help='Location on where to store experiment tracking logs` and relevent project information'						,    )
							a__     						=parser.parse_args()
							a__     						={'lr': 2e-5, 'num_epochs': 3, 'seed': 42, 'batch_size': 16}
							training_function(__a						,    __a    )


if __name__ == "__main__":
	main()





import os

import requests

_lowerCAmelCase:	int      							=					'https://www.amdoren.com/api/currency.php'


# Currency and their description
_lowerCAmelCase:	Dict      							=					'\nAED	United Arab Emirates Dirham\nAFN	Afghan Afghani\nALL	Albanian Lek\nAMD	Armenian Dram\nANG	Netherlands Antillean Guilder\nAOA	Angolan Kwanza\nARS	Argentine Peso\nAUD	Australian Dollar\nAWG	Aruban Florin\nAZN	Azerbaijani Manat\nBAM	Bosnia & Herzegovina Convertible Mark\nBBD	Barbadian Dollar\nBDT	Bangladeshi Taka\nBGN	Bulgarian Lev\nBHD	Bahraini Dinar\nBIF	Burundian Franc\nBMD	Bermudian Dollar\nBND	Brunei Dollar\nBOB	Bolivian Boliviano\nBRL	Brazilian Real\nBSD	Bahamian Dollar\nBTN	Bhutanese Ngultrum\nBWP	Botswana Pula\nBYN	Belarus Ruble\nBZD	Belize Dollar\nCAD	Canadian Dollar\nCDF	Congolese Franc\nCHF	Swiss Franc\nCLP	Chilean Peso\nCNY	Chinese Yuan\nCOP	Colombian Peso\nCRC	Costa Rican Colon\nCUC	Cuban Convertible Peso\nCVE	Cape Verdean Escudo\nCZK	Czech Republic Koruna\nDJF	Djiboutian Franc\nDKK	Danish Krone\nDOP	Dominican Peso\nDZD	Algerian Dinar\nEGP	Egyptian Pound\nERN	Eritrean Nakfa\nETB	Ethiopian Birr\nEUR	Euro\nFJD	Fiji Dollar\nGBP	British Pound Sterling\nGEL	Georgian Lari\nGHS	Ghanaian Cedi\nGIP	Gibraltar Pound\nGMD	Gambian Dalasi\nGNF	Guinea Franc\nGTQ	Guatemalan Quetzal\nGYD	Guyanaese Dollar\nHKD	Hong Kong Dollar\nHNL	Honduran Lempira\nHRK	Croatian Kuna\nHTG	Haiti Gourde\nHUF	Hungarian Forint\nIDR	Indonesian Rupiah\nILS	Israeli Shekel\nINR	Indian Rupee\nIQD	Iraqi Dinar\nIRR	Iranian Rial\nISK	Icelandic Krona\nJMD	Jamaican Dollar\nJOD	Jordanian Dinar\nJPY	Japanese Yen\nKES	Kenyan Shilling\nKGS	Kyrgystani Som\nKHR	Cambodian Riel\nKMF	Comorian Franc\nKPW	North Korean Won\nKRW	South Korean Won\nKWD	Kuwaiti Dinar\nKYD	Cayman Islands Dollar\nKZT	Kazakhstan Tenge\nLAK	Laotian Kip\nLBP	Lebanese Pound\nLKR	Sri Lankan Rupee\nLRD	Liberian Dollar\nLSL	Lesotho Loti\nLYD	Libyan Dinar\nMAD	Moroccan Dirham\nMDL	Moldovan Leu\nMGA	Malagasy Ariary\nMKD	Macedonian Denar\nMMK	Myanma Kyat\nMNT	Mongolian Tugrik\nMOP	Macau Pataca\nMRO	Mauritanian Ouguiya\nMUR	Mauritian Rupee\nMVR	Maldivian Rufiyaa\nMWK	Malawi Kwacha\nMXN	Mexican Peso\nMYR	Malaysian Ringgit\nMZN	Mozambican Metical\nNAD	Namibian Dollar\nNGN	Nigerian Naira\nNIO	Nicaragua Cordoba\nNOK	Norwegian Krone\nNPR	Nepalese Rupee\nNZD	New Zealand Dollar\nOMR	Omani Rial\nPAB	Panamanian Balboa\nPEN	Peruvian Nuevo Sol\nPGK	Papua New Guinean Kina\nPHP	Philippine Peso\nPKR	Pakistani Rupee\nPLN	Polish Zloty\nPYG	Paraguayan Guarani\nQAR	Qatari Riyal\nRON	Romanian Leu\nRSD	Serbian Dinar\nRUB	Russian Ruble\nRWF	Rwanda Franc\nSAR	Saudi Riyal\nSBD	Solomon Islands Dollar\nSCR	Seychellois Rupee\nSDG	Sudanese Pound\nSEK	Swedish Krona\nSGD	Singapore Dollar\nSHP	Saint Helena Pound\nSLL	Sierra Leonean Leone\nSOS	Somali Shilling\nSRD	Surinamese Dollar\nSSP	South Sudanese Pound\nSTD	Sao Tome and Principe Dobra\nSYP	Syrian Pound\nSZL	Swazi Lilangeni\nTHB	Thai Baht\nTJS	Tajikistan Somoni\nTMT	Turkmenistani Manat\nTND	Tunisian Dinar\nTOP	Tonga Paanga\nTRY	Turkish Lira\nTTD	Trinidad and Tobago Dollar\nTWD	New Taiwan Dollar\nTZS	Tanzanian Shilling\nUAH	Ukrainian Hryvnia\nUGX	Ugandan Shilling\nUSD	United States Dollar\nUYU	Uruguayan Peso\nUZS	Uzbekistan Som\nVEF	Venezuelan Bolivar\nVND	Vietnamese Dong\nVUV	Vanuatu Vatu\nWST	Samoan Tala\nXAF	Central African CFA franc\nXCD	East Caribbean Dollar\nXOF	West African CFA franc\nXPF	CFP Franc\nYER	Yemeni Rial\nZAR	South African Rand\nZMW	Zambian Kwacha\n'






def      _lowercase(				__a							:	str = "USD"						,    __a							:	str = "INR"						,    __a							:	float = 1.0						,    __a							:	str = ""    ):
							a__     						=locals()
							# from is a reserved keyword
							a__     						=params.pop('from_'    )
							a__     						=requests.get(__a						,    params=__a    ).json()
							return str(res['amount']    ) if res["error"] == 0 else res["error_message"]


if __name__ == "__main__":
	_lowerCAmelCase:	Union[str, Any]      							=					os.getenv('CI', '')
	_lowerCAmelCase:	Optional[Any]      							=					os.getenv('AMDOREN_API_KEY', '')

	if not API_KEY and not TESTING:
		raise KeyError(
		    'API key must be provided in the \'AMDOREN_API_KEY\' environment variable.'
		)

	print(
	    convert_currency(
	        input('Enter from currency: ').strip(),
	        input('Enter to currency: ').strip(),
	        float(input('Enter the amount: ').strip()),
	        API_KEY,
	    )
	)

