



'''simple docstring'''


import requests
from bsa import BeautifulSoup







def 				__lowerCamelCase				(   A__ = "AAPL"    )       ->	str:






   """simple docstring"""
   UpperCamelCase					=  F"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
   UpperCamelCase					=  BeautifulSoup(requests.get(A__    ).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}''')



import argparse
import glob
import logging
import os
import time
from argparse import Namespace

import numpy as np
import torch
from lightning_base import BaseTransformer, add_generic_args, generic_train
from torch.utils.data import DataLoader, TensorDataset

from transformers import glue_compute_metrics as compute_metrics
from transformers import glue_convert_examples_to_features as convert_examples_to_features
from transformers import glue_output_modes, glue_tasks_num_labels
from transformers import glue_processors as processors


UpperCAmelCase	      = logging.getLogger(__name__)







class        A_   (			__lowerCamelCase   ):




	'''simple docstring'''


	_UpperCamelCase     :     Optional[int]							 =       """sequence-classification"""





	def __init__(       self		,    snake_case       ):
		if type(snake_case       ) == dict:
			lowercase       =    Namespace(**snake_case       )
		lowercase       =    glue_output_modes[hparams.task]
		lowercase       =    glue_tasks_num_labels[hparams.task]

		super().__init__(snake_case		,    snake_case		,    self.mode       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    **snake_case       ):
		return self.model(**snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case       ):
		lowercase       =    {'input_ids': batch[0], 'attention_mask': batch[1], 'labels': batch[3]}

		if self.config.model_type not in ["distilbert", "bart"]:
			lowercase       =    batch[2] if self.config.model_type in ['bert', 'xlnet', 'albert'] else None

		lowercase       =    self(**snake_case       )
		lowercase       =    outputs[0]

		lowercase       =    self.trainer.lr_schedulers[0]['scheduler']
		lowercase       =    {'loss': loss, 'rate': lr_scheduler.get_last_lr()[-1]}
		return {"loss": loss, "log": tensorboard_logs}





	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		lowercase       =    self.hparams
		lowercase       =    processors[args.task]()
		lowercase       =    processor.get_labels()

		for mode in ["train", "dev"]:
			lowercase       =    self._feature_file(snake_case       )
			if os.path.exists(snake_case       ) and not args.overwrite_cache:
				logger.info('Loading features from cached file %s'		,    snake_case       )
			else:
				logger.info('Creating features from dataset file at %s'		,    args.data_dir       )
				lowercase       =    (
				    processor.get_dev_examples(args.data_dir       )
				    if mode == 'dev'
				    else processor.get_train_examples(args.data_dir       )
				)
				lowercase       =    convert_examples_to_features(
				    snake_case		,    self.tokenizer		,    max_length=args.max_seq_length		,    label_list=self.labels		,    output_mode=args.glue_output_mode		,    )
				logger.info('Saving features into cached file %s'		,    snake_case       )
				torch.save(snake_case		,    snake_case       )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case = False       ):
		lowercase       =    'dev' if mode == 'test' else mode

		lowercase       =    self._feature_file(snake_case       )
		logger.info('Loading features from cached file %s'		,    snake_case       )
		lowercase       =    torch.load(snake_case       )
		lowercase       =    torch.tensor([f.input_ids for f in features]		,    dtype=torch.long       )
		lowercase       =    torch.tensor([f.attention_mask for f in features]		,    dtype=torch.long       )
		lowercase       =    torch.tensor([f.token_type_ids for f in features]		,    dtype=torch.long       )
		if self.hparams.glue_output_mode == "classification":
			lowercase       =    torch.tensor([f.label for f in features]		,    dtype=torch.long       )
		elif self.hparams.glue_output_mode == "regression":
			lowercase       =    torch.tensor([f.label for f in features]		,    dtype=torch.float       )

		return DataLoader(
		    TensorDataset(snake_case		,    snake_case		,    snake_case		,    snake_case       )		,    batch_size=snake_case		,    shuffle=snake_case		,    )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case       ):
		lowercase       =    {'input_ids': batch[0], 'attention_mask': batch[1], 'labels': batch[3]}

		if self.config.model_type not in ["distilbert", "bart"]:
			lowercase       =    batch[2] if self.config.model_type in ['bert', 'xlnet', 'albert'] else None

		lowercase       =    self(**snake_case       )
		lowercase  ,					lowercase       =    outputs[:2]
		lowercase       =    logits.detach().cpu().numpy()
		lowercase       =    inputs['labels'].detach().cpu().numpy()

		return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case       ):
		lowercase       =    torch.stack([x['val_loss'] for x in outputs]       ).mean().detach().cpu().item()
		lowercase       =    np.concatenate([x['pred'] for x in outputs]		,    axis=0       )

		if self.hparams.glue_output_mode == "classification":
			lowercase       =    np.argmax(snake_case		,    axis=1       )
		elif self.hparams.glue_output_mode == "regression":
			lowercase       =    np.squeeze(snake_case       )

		lowercase       =    np.concatenate([x['target'] for x in outputs]		,    axis=0       )
		lowercase       =    [[] for _ in range(out_label_ids.shape[0]       )]
		lowercase       =    [[] for _ in range(out_label_ids.shape[0]       )]

		lowercase       =    {**{'val_loss': val_loss_mean}, **compute_metrics(self.hparams.task		,    snake_case		,    snake_case       )}

		lowercase       =    dict(results.items()       )
		lowercase       =    results
		return ret, preds_list, out_label_list





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case       ):
		lowercase  ,					lowercase  ,					lowercase       =    self._eval_end(snake_case       )
		lowercase       =    ret['log']
		return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case       ):
		lowercase  ,					lowercase  ,					lowercase       =    self._eval_end(snake_case       )
		lowercase       =    ret['log']
		# `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss`
		return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs}





	@staticmethod
	def 	SCREAMING_SNAKE_CASE__						(       snake_case		,    snake_case       ):
		BaseTransformer.add_model_specific_args(snake_case		,    snake_case       )
		parser.add_argument(
		    '--max_seq_length'		,    default=128		,    type=snake_case		,    help=(
		        'The maximum total input sequence length after tokenization. Sequences longer '
		        'than this will be truncated, sequences shorter will be padded.'
		    )		,    )

		parser.add_argument(
		    '--task'		,    default=''		,    type=snake_case		,    required=snake_case		,    help='The GLUE task to run'		,    )
		parser.add_argument(
		    '--gpus'		,    default=0		,    type=snake_case		,    help='The number of GPUs allocated for this, it is by default 0 meaning none'		,    )

		parser.add_argument(
		    '--overwrite_cache'		,    action='store_true'		,    help='Overwrite the cached training and evaluation sets'       )

		return parser






def 							UpperCAmelCase_		(							):
	lowercase       =    argparse.ArgumentParser()
	add_generic_args(__SCREAMING_SNAKE_CASE ,							os.getcwd()							)
	lowercase       =    GLUETransformer.add_model_specific_args(__SCREAMING_SNAKE_CASE ,							os.getcwd()							)
	lowercase       =    parser.parse_args()

	# If output_dir not provided, a folder will be generated in pwd
	if args.output_dir is None:
		lowercase       =    os.path.join(
		    './results' ,							F'''{args.task}_{time.strftime('%Y%m%d_%H%M%S'							)}''' ,							)
		os.makedirs(args.output_dir							)

	lowercase       =    GLUETransformer(__SCREAMING_SNAKE_CASE							)
	lowercase       =    generic_train(__SCREAMING_SNAKE_CASE ,							__SCREAMING_SNAKE_CASE							)

	# Optionally, predict on dev set and write to output_dir
	if args.do_predict:
		lowercase       =    sorted(glob.glob(os.path.join(args.output_dir ,							'checkpoint-epoch=*.ckpt'							) ,							recursive=__SCREAMING_SNAKE_CASE							)							)
		lowercase       =    model.load_from_checkpoint(checkpoints[-1]							)
		return trainer.test(__SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
	main()

