

import argparse
import logging
from collections import namedtuple

import torch
from model_bertabs import BertAbsSummarizer
from models.model_builder import AbsSummarizer  # The authors' implementation

from transformers import BertTokenizer


logging.basicConfig(level=logging.INFO)
a_     =			logging.getLogger(__name__)


a_     =			'Hello world! cécé herlolip'


a_     =			namedtuple(
    'BertAbsConfig',
    [
        'temp_dir',
        'large',
        'use_bert_emb',
        'finetune_bert',
        'encoder',
        'share_emb',
        'max_pos',
        'enc_layers',
        'enc_hidden_size',
        'enc_heads',
        'enc_ff_size',
        'enc_dropout',
        'dec_layers',
        'dec_hidden_size',
        'dec_heads',
        'dec_ff_size',
        'dec_dropout',
    ],
)

def        lowerCamelCase__       (    _a							,	_a):
	SCREAMING_SNAKE_CASE      :					Optional[Any]    =				BertAbsConfig(
	    temp_dir="."							,	finetune_bert=snake_case_							,	large=snake_case_							,	share_emb=snake_case_							,	use_bert_emb=snake_case_							,	encoder="bert"							,	max_pos=512							,	enc_layers=6							,	enc_hidden_size=512							,	enc_heads=8							,	enc_ff_size=512							,	enc_dropout=0.2							,	dec_layers=6							,	dec_hidden_size=768							,	dec_heads=8							,	dec_ff_size=2048							,	dec_dropout=0.2							,	)
	SCREAMING_SNAKE_CASE      :					Optional[int]    =				torch.load(snake_case_							,	lambda _a							,	_a: storage)
	SCREAMING_SNAKE_CASE      :					Optional[int]    =				AbsSummarizer(snake_case_							,	torch.device("cpu")							,	snake_case_)
	original.eval()

	SCREAMING_SNAKE_CASE      :					List[str]    =				BertAbsSummarizer(snake_case_							,	torch.device("cpu"))
	new_model.eval()

	# -------------------
	# Convert the weights
	# -------------------

	logging.info("convert the model")
	new_model.bert.load_state_dict(original.bert.state_dict())
	new_model.decoder.load_state_dict(original.decoder.state_dict())
	new_model.generator.load_state_dict(original.generator.state_dict())

	# ----------------------------------
	# Make sure the outpus are identical
	# ----------------------------------

	logging.info("Make sure that the models' outputs are identical")
	SCREAMING_SNAKE_CASE      :					List[str]    =				BertTokenizer.from_pretrained("bert-base-uncased")

	# prepare the model inputs
	SCREAMING_SNAKE_CASE      :					List[Any]    =				tokenizer.encode("This is sample éàalj'-.")
	encoder_input_ids.extend([tokenizer.pad_token_id] * (512 - len(snake_case_)))
	SCREAMING_SNAKE_CASE      :					int    =				torch.tensor(snake_case_).unsqueeze(0)
	SCREAMING_SNAKE_CASE      :					Any    =				tokenizer.encode("This is sample 3 éàalj'-.")
	decoder_input_ids.extend([tokenizer.pad_token_id] * (512 - len(snake_case_)))
	SCREAMING_SNAKE_CASE      :					List[str]    =				torch.tensor(snake_case_).unsqueeze(0)

	# failsafe to make sure the weights reset does not affect the
	# loaded weights.
	assert torch.max(torch.abs(original.generator[0].weight - new_model.generator[0].weight)) == 0

	# forward pass
	SCREAMING_SNAKE_CASE      :					List[str]    =				encoder_input_ids
	SCREAMING_SNAKE_CASE      :					int    =				decoder_input_ids
	SCREAMING_SNAKE_CASE      :					Tuple    =				None
	SCREAMING_SNAKE_CASE      :					List[Any]    =				None
	SCREAMING_SNAKE_CASE      :					Tuple    =				None
	SCREAMING_SNAKE_CASE      :					Tuple    =				None
	SCREAMING_SNAKE_CASE      :					List[str]    =				None

	# The original model does not apply the geneator layer immediatly but rather in
	# the beam search (where it combines softmax + linear layer). Since we already
	# apply the softmax in our generation process we only apply the linear layer here.
	# We make sure that the outputs of the full stack are identical
	SCREAMING_SNAKE_CASE      :					List[str]    =				original(snake_case_							,	snake_case_							,	snake_case_							,	snake_case_							,	snake_case_							,	snake_case_							,	snake_case_)[0]
	SCREAMING_SNAKE_CASE      :					List[str]    =				original.generator(snake_case_)

	SCREAMING_SNAKE_CASE      :					str    =				new_model(
	    snake_case_							,	snake_case_							,	snake_case_							,	snake_case_							,	snake_case_)[0]
	SCREAMING_SNAKE_CASE      :					Optional[Any]    =				new_model.generator(snake_case_)

	SCREAMING_SNAKE_CASE      :					int    =				torch.max(torch.abs(output_converted_model - output_original_model)).item()
	print("Maximum absolute difference beween weights: {:.2f}".format(snake_case_))
	SCREAMING_SNAKE_CASE      :					str    =				torch.max(torch.abs(output_converted_generator - output_original_generator)).item()
	print("Maximum absolute difference beween weights: {:.2f}".format(snake_case_))

	SCREAMING_SNAKE_CASE      :					Optional[Any]    =				torch.allclose(snake_case_							,	snake_case_							,	atol=1E-3)
	if are_identical:
		logging.info("all weights are equal up to 1e-3")
	else:
		raise ValueError("the weights are different. The new model is likely different from the original one.")

	# The model has been saved with torch.save(model) and this is bound to the exact
	# directory structure. We save the state_dict instead.
	logging.info("saving the model's state dictionary")
	torch.save(
	    new_model.state_dict()							,	"./bertabs-finetuned-cnndm-extractive-abstractive-summarization/pytorch_model.bin")


if __name__ == "__main__":
			a_     =			argparse.ArgumentParser()
			parser.add_argument(
			    '--bertabs_checkpoint_path',
			    default=None,
			    type=str,
			    required=True,
			    help='Path the official PyTorch dump.',
			)
			parser.add_argument(
			    '--pytorch_dump_folder_path',
			    default=None,
			    type=str,
			    required=True,
			    help='Path to the output PyTorch model.',
			)
			a_     =			parser.parse_args()

			convert_bertabs_checkpoints(
			    args.bertabs_checkpoint_path,
			    args.pytorch_dump_folder_path,
			)





import requests
from bsa import BeautifulSoup







def 				lowerCAmelCase_	(     snake_case_ = "AAPL"     ):
      _A							:     str			=						f'''https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'''
      _A							:     List[Any]			=						BeautifulSoup(requests.get(snake_case_     ).text,"""html.parser"""     )
      _A							:     Union[str, Any]			=						"""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}""")

