

import argparse
from typing import Dict

import tensorflow as tf
import torch
from tqdm import tqdm

from transformers import BigBirdPegasusConfig, BigBirdPegasusForConditionalGeneration


lowerCAmelCase_			      =      [
    # tf -> hf
    ('''/''', '''.'''),
    ('''layer_''', '''layers.'''),
    ('''kernel''', '''weight'''),
    ('''beta''', '''bias'''),
    ('''gamma''', '''weight'''),
    ('''pegasus''', '''model'''),
]
lowerCAmelCase_			      =      [
    ('''.output.dense''', '''.fc2'''),
    ('''intermediate.LayerNorm''', '''final_layer_norm'''),
    ('''intermediate.dense''', '''fc1'''),
]

lowerCAmelCase_			      =      (
    INIT_COMMON
    + [
        ('''attention.self.LayerNorm''', '''self_attn_layer_norm'''),
        ('''attention.output.dense''', '''self_attn.out_proj'''),
        ('''attention.self''', '''self_attn'''),
        ('''attention.encdec.LayerNorm''', '''encoder_attn_layer_norm'''),
        ('''attention.encdec_output.dense''', '''encoder_attn.out_proj'''),
        ('''attention.encdec''', '''encoder_attn'''),
        ('''key''', '''k_proj'''),
        ('''value''', '''v_proj'''),
        ('''query''', '''q_proj'''),
        ('''decoder.LayerNorm''', '''decoder.layernorm_embedding'''),
    ]
    + END_COMMON
)

lowerCAmelCase_			      =      (
    INIT_COMMON
    + [
        ('''embeddings.word_embeddings''', '''shared.weight'''),
        ('''embeddings.position_embeddings''', '''embed_positions.weight'''),
        ('''attention.self.LayerNorm''', '''self_attn_layer_norm'''),
        ('''attention.output.dense''', '''self_attn.output'''),
        ('''attention.self''', '''self_attn.self'''),
        ('''encoder.LayerNorm''', '''encoder.layernorm_embedding'''),
    ]
    + END_COMMON
)

lowerCAmelCase_			      =      [
    '''encdec/key/bias''',
    '''encdec/query/bias''',
    '''encdec/value/bias''',
    '''self/key/bias''',
    '''self/query/bias''',
    '''self/value/bias''',
    '''encdec_output/dense/bias''',
    '''attention/output/dense/bias''',
]


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			):
						for tf_name, hf_name in patterns:
												snake_case_  =      k.replace(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			)
						return k


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			):
						snake_case_  =      BigBirdPegasusConfig(**SCREAMING_SNAKE_CASE__			)
						snake_case_  =      BigBirdPegasusForConditionalGeneration(SCREAMING_SNAKE_CASE__			)
						snake_case_  =      torch_model.state_dict()
						snake_case_  =      {}

						# separating decoder weights
						snake_case_  =      {k: tf_weights[k] for k in tf_weights if k.startswith('''pegasus/decoder'''			)}
						snake_case_  =      {k: tf_weights[k] for k in tf_weights if not k.startswith('''pegasus/decoder'''			)}

						for k, v in tqdm(decoder_weights.items()    ,						'''tf -> hf conversion'''			):
												snake_case_  =      [k.endswith(SCREAMING_SNAKE_CASE__			) for ending in KEYS_TO_IGNORE]
												if any(SCREAMING_SNAKE_CASE__			):
																		continue
												snake_case_  =      DECODER_PATTERNS
												snake_case_  =      rename_state_dict_key(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			)
												if new_k not in state_dict:
																		raise ValueError(F'''could not find new key {new_k} in state dict. (converted from {k})'''			)
												if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value''']			):
																		snake_case_  =      v.T
												snake_case_  =      torch.from_numpy(SCREAMING_SNAKE_CASE__			)
												assert v.shape == state_dict[new_k].shape, F'''{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}'''

						for k, v in tqdm(remaining_weights.items()    ,						'''tf -> hf conversion'''			):
												snake_case_  =      [k.endswith(SCREAMING_SNAKE_CASE__			) for ending in KEYS_TO_IGNORE]
												if any(SCREAMING_SNAKE_CASE__			):
																		continue
												snake_case_  =      REMAINING_PATTERNS
												snake_case_  =      rename_state_dict_key(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			)
												if new_k not in state_dict and k != "pegasus/embeddings/position_embeddings":
																		raise ValueError(F'''could not find new key {new_k} in state dict. (converted from {k})'''			)
												if any(True if i in k else False for i in ['''dense''', '''query''', '''key''', '''value''']			):
																		snake_case_  =      v.T
												snake_case_  =      torch.from_numpy(SCREAMING_SNAKE_CASE__			)
												if k != "pegasus/embeddings/position_embeddings":
																		assert v.shape == state_dict[new_k].shape, F'''{new_k}, {k}, {v.shape}, {state_dict[new_k].shape}'''

						snake_case_  =      mapping['''model.embed_positions.weight''']
						snake_case_  =      mapping.pop('''model.embed_positions.weight'''			)
						snake_case_,       snake_case_  =      torch_model.load_state_dict(SCREAMING_SNAKE_CASE__    ,						strict=SCREAMING_SNAKE_CASE__			)
						snake_case_  =      [
						    k
						    for k in missing
						    if k
						    not in [
						        '''final_logits_bias''',
						        '''model.encoder.embed_tokens.weight''',
						        '''model.decoder.embed_tokens.weight''',
						        '''lm_head.weight''',
						    ]
						]
						assert unexpected_missing == [], F'''no matches found for the following torch keys {unexpected_missing}'''
						assert extra == [], F'''no matches found for the following tf keys {extra}'''
						return torch_model


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__			):
						snake_case_  =      tf.train.list_variables(SCREAMING_SNAKE_CASE__			)
						snake_case_  =      {}
						snake_case_  =      ['''global_step''']
						for name, shape in tqdm(SCREAMING_SNAKE_CASE__    ,						desc='''converting tf checkpoint to dict'''			):
												snake_case_  =      any(pat in name for pat in ignore_name			)
												if skip_key:
																		continue
												snake_case_  =      tf.train.load_variable(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			)
												snake_case_  =      array
						return tf_weights


def     __SCREAMING_SNAKE_CASE   (SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			):
						snake_case_  =      get_tf_weights_as_numpy(SCREAMING_SNAKE_CASE__			)
						snake_case_  =      convert_bigbird_pegasus(SCREAMING_SNAKE_CASE__    ,						SCREAMING_SNAKE_CASE__			)
						torch_model.save_pretrained(SCREAMING_SNAKE_CASE__			)


if __name__ == "__main__":
					lowerCAmelCase_			      =      argparse.ArgumentParser()
					parser.add_argument('''--tf_ckpt_path''', type=str, help='''passed to tf.train.list_variables''')
					parser.add_argument('''--save_dir''', default=None, type=str, help='''Path to the output PyTorch model.''')
					lowerCAmelCase_			      =      parser.parse_args()
					lowerCAmelCase_			      =      {}
					convert_bigbird_pegasus_ckpt_to_pytorch(args.tf_ckpt_path, args.save_dir, config_update=config_update)



import requests
from bsa import BeautifulSoup
def 							UpperCamelCase_(					_A :str = "AAPL"	)->		str:
			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}''')


