
'''simple docstring'''



import re

import jax.numpy as jnp
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.random import PRNGKey

from ..utils import logging


_lowercase          =						logging.get_logger(__name__)


def A (__lowerCamelCase :List[str]						):
						_lowerCAmelCase    		=					r"""\w+[.]\d+"""
						_lowerCAmelCase    		=					re.findall(__lowerCamelCase					,      __lowerCamelCase						)
						for pat in pats:
												_lowerCAmelCase    		=					key.replace(__lowerCamelCase					,      """_""".join(pat.split("""."""						)						)						)
						return key


def A (__lowerCamelCase :Union[str, Any]					,      __lowerCamelCase :Any					,      __lowerCamelCase :int						):
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""scale""",)
						if (
						    any("""norm""" in str_ for str_ in pt_tuple_key						)
						    and (pt_tuple_key[-1] == "bias")
						    and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict)
						    and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict)
						):
												_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""scale""",)
												return renamed_pt_tuple_key, pt_tensor
						elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict:
												_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""scale""",)
												return renamed_pt_tuple_key, pt_tensor

						# embedding
						if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict:
												_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""embedding""",)
												return renamed_pt_tuple_key, pt_tensor

						# conv layer
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""kernel""",)
						if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4:
												_lowerCAmelCase    		=					pt_tensor.transpose(2					,      3					,      1					,      0						)
												return renamed_pt_tuple_key, pt_tensor

						# linear layer
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""kernel""",)
						if pt_tuple_key[-1] == "weight":
												_lowerCAmelCase    		=					pt_tensor.T
												return renamed_pt_tuple_key, pt_tensor

						# old PyTorch layer norm weight
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""weight""",)
						if pt_tuple_key[-1] == "gamma":
												return renamed_pt_tuple_key, pt_tensor

						# old PyTorch layer norm bias
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""bias""",)
						if pt_tuple_key[-1] == "beta":
												return renamed_pt_tuple_key, pt_tensor

						return pt_tuple_key, pt_tensor





def A (__lowerCamelCase :Any					,      __lowerCamelCase :int					,      __lowerCamelCase :Dict=42						):
						# Step 1: Convert pytorch tensor to numpy
						_lowerCAmelCase    		=					{k: v.numpy() for k, v in pt_state_dict.items()}

						# Step 2: Since the model is stateless, get random Flax params
						_lowerCAmelCase    		=					flax_model.init_weights(PRNGKey(__lowerCamelCase						)						)

						_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)
						_lowerCAmelCase    		=					{}

						# Need to change some parameters name to match Flax names
						for pt_key, pt_tensor in pt_state_dict.items():
												_lowerCAmelCase    		=					rename_key(__lowerCamelCase						)
												_lowerCAmelCase    		=					tuple(renamed_pt_key.split("""."""						)						)

												# Correctly rename weight parameters
												_lowerCAmelCase		,       _lowerCAmelCase    		=					rename_key_and_reshape_tensor(__lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)

												if flax_key in random_flax_state_dict:
																		if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
																								raise ValueError(
																								    f'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '
																								    f'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)

        # also add unexpected weight so that warning is thrown
												_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)

						return unflatten_dict(__lowerCamelCase						)


'''simple docstring'''



import sys
import webbrowser

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
						print("""Googling.....""")
						_lowercase          =						"""https://www.google.com/search?q=""" + """ """.join(sys.argv[1:])
						_lowercase          =						requests.get(url, headers={"""UserAgent""": UserAgent().random})
						# res.raise_for_status()
						with open("""project1a.html""", """wb""") as out_file:  # only for knowing the class
												for data in res.iter_content(10000):
																		out_file.write(data)
						_lowercase          =						BeautifulSoup(res.text, """html.parser""")
						_lowercase          =						list(soup.select(""".eZt8xd"""))[:5]

						print(len(links))
						for link in links:
												if link.text == "Maps":
																		webbrowser.open(link.get("""href"""))
												else:
																		webbrowser.open(F"""https://google.com{link.get('href')}""")
