
'''simple docstring'''



import os
from pickle import UnpicklingError
from typing import Dict, Tuple

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict, unflatten_dict

import transformers

from .utils import logging


_lowercase          =						logging.get_logger(__name__)


def A (__lowerCamelCase :str					,      __lowerCamelCase :List[str]					,      __lowerCamelCase :str					,      __lowerCamelCase :Optional[Any]=False						):
						try:
												import torch  # noqa: F401
						except ImportError:
												logger.error(
												    """Loading a PyTorch model in Flax, requires both PyTorch and Flax to be installed. Please see"""
												    """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
												    """ instructions."""						)
												raise

						if not is_sharded:
												_lowerCAmelCase    		=					os.path.abspath(__lowerCamelCase						)
												logger.info(f'Loading PyTorch weights from {pt_path}'						)

												_lowerCAmelCase    		=					torch.load(__lowerCamelCase					,      map_location="""cpu"""						)
												logger.info(f'PyTorch checkpoint contains {sum(t.numel() for t in pt_state_dict.values()						):,} parameters.'						)

												_lowerCAmelCase    		=					convert_pytorch_state_dict_to_flax(__lowerCamelCase					,      __lowerCamelCase						)
						else:
												# model is sharded and pytorch_checkpoint_path already contains the list of .pt shard files
												_lowerCAmelCase    		=					convert_pytorch_sharded_state_dict_to_flax(__lowerCamelCase					,      __lowerCamelCase						)
						return flax_state_dict


def A (__lowerCamelCase :Tuple[str]					,      __lowerCamelCase :np.ndarray					,      __lowerCamelCase :Dict[str, jnp.ndarray]					,      __lowerCamelCase :str					,      ):

						def is_key_or_prefix_key_in_dict(__lowerCamelCase :Tuple[str]						) -> bool:
												return len(set(__lowerCamelCase						) & {key, (model_prefix,) + key}						) > 0

						# layer norm
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""scale""",)
						if pt_tuple_key[-1] in ["weight", "gamma"] and is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												return renamed_pt_tuple_key, pt_tensor

						# batch norm layer mean
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""mean""",)
						if pt_tuple_key[-1] == "running_mean" and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												return renamed_pt_tuple_key, pt_tensor

						# batch norm layer var
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""var""",)
						if pt_tuple_key[-1] == "running_var" and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												return renamed_pt_tuple_key, pt_tensor

						# embedding
						_lowerCAmelCase    		=					pt_tuple_key[:-1] + ("""embedding""",)
						if pt_tuple_key[-1] == "weight" and is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												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 and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												_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" and not is_key_or_prefix_key_in_dict(__lowerCamelCase						):
												_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

						# New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
						_lowerCAmelCase    		=					None
						if pt_tuple_key[-3::2] == ("parametrizations", "original0"):
												_lowerCAmelCase    		=					pt_tuple_key[-2] + """_g"""
						elif pt_tuple_key[-3::2] == ("parametrizations", "original1"):
												_lowerCAmelCase    		=					pt_tuple_key[-2] + """_v"""
						if name is not None:
												_lowerCAmelCase    		=					pt_tuple_key[:-3] + (name,)
												return renamed_pt_tuple_key, pt_tensor

						return pt_tuple_key, pt_tensor


def A (__lowerCamelCase :Union[str, Any]					,      __lowerCamelCase :Dict						):
						# convert pytorch tensor to numpy
						_lowerCAmelCase    		=					{k: v.numpy() for k, v in pt_state_dict.items()}

						_lowerCAmelCase    		=					flax_model.base_model_prefix

						# use params dict if the model contains batch norm layers
						if "params" in flax_model.params:
												_lowerCAmelCase    		=					flax_model.params["""params"""]
						else:
												_lowerCAmelCase    		=					flax_model.params
						_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)

						# add batch_stats keys,values to dict
						if "batch_stats" in flax_model.params:
												_lowerCAmelCase    		=					flatten_dict(flax_model.params["""batch_stats"""]						)
												random_flax_state_dict.update(__lowerCamelCase						)

						_lowerCAmelCase    		=					{}

						_lowerCAmelCase    		=					(model_prefix not in flax_model_params) and (
						    model_prefix in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
						)
						_lowerCAmelCase    		=					(model_prefix in flax_model_params) and (
						    model_prefix not in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
						)

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

												# remove base model prefix if necessary
												_lowerCAmelCase    		=					pt_tuple_key[0] == model_prefix
												if load_model_with_head_into_base_model and has_base_model_prefix:
																		_lowerCAmelCase    		=					pt_tuple_key[1:]

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

												# add model prefix if necessary
												_lowerCAmelCase    		=					(model_prefix,) + flax_key in random_flax_state_dict
												if load_base_model_into_model_with_head and require_base_model_prefix:
																		_lowerCAmelCase    		=					(model_prefix,) + flax_key

												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}.'						)

        # add batch stats if the model contains batchnorm layers
												if "batch_stats" in flax_model.params:
																		if "mean" in flax_key[-1] or "var" in flax_key[-1]:
																								_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)
																								continue
																		# remove num_batches_tracked key
																		if "num_batches_tracked" in flax_key[-1]:
																								flax_state_dict.pop(__lowerCamelCase					,      __lowerCamelCase						)
																								continue

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

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

						return unflatten_dict(__lowerCamelCase						)


def A (__lowerCamelCase :List[str]					,      __lowerCamelCase :List[str]						):
						import torch

						# Load the index
						_lowerCAmelCase    		=					{}
						for shard_file in shard_filenames:
												# load using msgpack utils
												_lowerCAmelCase    		=					torch.load(__lowerCamelCase						)
												_lowerCAmelCase    		=					{k: v.numpy() for k, v in pt_state_dict.items()}

												_lowerCAmelCase    		=					flax_model.base_model_prefix

												# use params dict if the model contains batch norm layers and then add batch_stats keys,values to dict
												if "batch_stats" in flax_model.params:
																		_lowerCAmelCase    		=					flax_model.params["""params"""]

																		_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)
																		random_flax_state_dict.update(flatten_dict(flax_model.params["""batch_stats"""]						)						)
												else:
																		_lowerCAmelCase    		=					flax_model.params
																		_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)

												_lowerCAmelCase    		=					(model_prefix not in flax_model_params) and (
												    model_prefix in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
												)
												_lowerCAmelCase    		=					(model_prefix in flax_model_params) and (
												    model_prefix not in {k.split("""."""						)[0] for k in pt_state_dict.keys()}
												)
												# Need to change some parameters name to match Flax names
												for pt_key, pt_tensor in pt_state_dict.items():
																		_lowerCAmelCase    		=					tuple(pt_key.split("""."""						)						)

																		# remove base model prefix if necessary
																		_lowerCAmelCase    		=					pt_tuple_key[0] == model_prefix
																		if load_model_with_head_into_base_model and has_base_model_prefix:
																								_lowerCAmelCase    		=					pt_tuple_key[1:]

																		# Correctly rename weight parameters
																		_lowerCAmelCase		,       _lowerCAmelCase    		=					rename_key_and_reshape_tensor(
																		    __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase					,      __lowerCamelCase						)
																		# add model prefix if necessary
																		_lowerCAmelCase    		=					(model_prefix,) + flax_key in random_flax_state_dict
																		if load_base_model_into_model_with_head and require_base_model_prefix:
																								_lowerCAmelCase    		=					(model_prefix,) + flax_key

																		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}.'						)

            # add batch stats if the model contains batchnorm layers
																		if "batch_stats" in flax_model.params:
																								if "mean" in flax_key[-1]:
																														_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)
																														continue
																								if "var" in flax_key[-1]:
																														_lowerCAmelCase    		=					jnp.asarray(__lowerCamelCase						)
																														continue
																								# remove num_batches_tracked key
																								if "num_batches_tracked" in flax_key[-1]:
																														flax_state_dict.pop(__lowerCamelCase					,      __lowerCamelCase						)
																														continue

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

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


def A (__lowerCamelCase :Tuple					,      __lowerCamelCase :List[str]						):
						_lowerCAmelCase    		=					os.path.abspath(__lowerCamelCase						)
						logger.info(f'Loading Flax weights from {flax_checkpoint_path}'						)

						# import correct flax class
						_lowerCAmelCase    		=					getattr(__lowerCamelCase					,      """Flax""" + model.__class__.__name__						)

						# load flax weight dict
						with open(__lowerCamelCase					,      """rb"""						) as state_f:
												try:
																		_lowerCAmelCase    		=					from_bytes(__lowerCamelCase					,      state_f.read()						)
												except UnpicklingError:
																		raise EnvironmentError(f'Unable to convert {flax_checkpoint_path} to Flax deserializable object. '						)

						return load_flax_weights_in_pytorch_model(__lowerCamelCase					,      __lowerCamelCase						)





def A (__lowerCamelCase :Optional[int]					,      __lowerCamelCase :Optional[int]						):

						try:
												import torch  # noqa: F401
						except ImportError:
												logger.error(
												    """Loading a Flax weights in PyTorch, requires both PyTorch and Flax to be installed. Please see"""
												    """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
												    """ instructions."""						)
												raise

						# check if we have bf16 weights
						_lowerCAmelCase    		=					flatten_dict(jax.tree_util.tree_map(lambda __lowerCamelCase						: x.dtype == jnp.bfloataa					,      __lowerCamelCase						)						).values()
						if any(__lowerCamelCase						):
												# convert all weights to fp32 if the are bf16 since torch.from_numpy can-not handle bf16
												# and bf16 is not fully supported in PT yet.
												logger.warning(
												    """Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` """
												    """before loading those in PyTorch model."""						)
												_lowerCAmelCase    		=					jax.tree_util.tree_map(
												    lambda __lowerCamelCase						: params.astype(np.floataa						) if params.dtype == jnp.bfloataa else params					,      __lowerCamelCase						)

						_lowerCAmelCase    		=					flatten_dict(__lowerCamelCase						)
						_lowerCAmelCase    		=					pt_model.state_dict()

						_lowerCAmelCase    		=					(pt_model.base_model_prefix in flax_state) and (
						    pt_model.base_model_prefix not in {k.split("""."""						)[0] for k in pt_model_dict.keys()}
						)
						_lowerCAmelCase    		=					(pt_model.base_model_prefix not in flax_state) and (
						    pt_model.base_model_prefix in {k.split("""."""						)[0] for k in pt_model_dict.keys()}
						)

						# keep track of unexpected & missing keys
						_lowerCAmelCase    		=					[]
						_lowerCAmelCase    		=					set(pt_model_dict.keys()						)

						for flax_key_tuple, flax_tensor in flax_state_dict.items():
												_lowerCAmelCase    		=					flax_key_tuple[0] == pt_model.base_model_prefix
												_lowerCAmelCase    		=					""".""".join((pt_model.base_model_prefix,) + flax_key_tuple						) in pt_model_dict

												# adapt flax_key to prepare for loading from/to base model only
												if load_model_with_head_into_base_model and has_base_model_prefix:
																		_lowerCAmelCase    		=					flax_key_tuple[1:]
												elif load_base_model_into_model_with_head and require_base_model_prefix:
																		_lowerCAmelCase    		=					(pt_model.base_model_prefix,) + flax_key_tuple

												# rename flax weights to PyTorch format
												if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 4 and ".".join(__lowerCamelCase						) not in pt_model_dict:
																		# conv layer
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""weight""",)
																		_lowerCAmelCase    		=					jnp.transpose(__lowerCamelCase					,      (3, 2, 0, 1)						)
												elif flax_key_tuple[-1] == "kernel" and ".".join(__lowerCamelCase						) not in pt_model_dict:
																		# linear layer
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""weight""",)
																		_lowerCAmelCase    		=					flax_tensor.T
												elif flax_key_tuple[-1] in ["scale", "embedding"]:
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""weight""",)

												# adding batch stats from flax batch norm to pt
												elif "mean" in flax_key_tuple[-1]:
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""running_mean""",)
												elif "var" in flax_key_tuple[-1]:
																		_lowerCAmelCase    		=					flax_key_tuple[:-1] + ("""running_var""",)

												if "batch_stats" in flax_state:
																		_lowerCAmelCase    		=					""".""".join(flax_key_tuple[1:]						)  # Remove the params/batch_stats header
												else:
																		_lowerCAmelCase    		=					""".""".join(__lowerCamelCase						)

												# We also need to look at `pt_model_dict` and see if there are keys requiring further transformation.
												_lowerCAmelCase    		=					{}
												# New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
												for key in pt_model_dict:
																		_lowerCAmelCase    		=					key.split("""."""						)
																		_lowerCAmelCase    		=					None
																		if key_components[-3::2] == ["parametrizations", "original0"]:
																								_lowerCAmelCase    		=					key_components[-2] + """_g"""
																		elif key_components[-3::2] == ["parametrizations", "original1"]:
																								_lowerCAmelCase    		=					key_components[-2] + """_v"""
																		if name is not None:
																								_lowerCAmelCase    		=					key_components[:-3] + [name]
																								_lowerCAmelCase    		=					""".""".join(__lowerCamelCase						)
																								_lowerCAmelCase    		=					key

												if flax_key in special_pt_names:
																		_lowerCAmelCase    		=					special_pt_names[flax_key]

												if flax_key in pt_model_dict:
																		if flax_tensor.shape != pt_model_dict[flax_key].shape:
																								raise ValueError(
																								    f'Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected '
																								    f'to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)
																		else:
																								# add weight to pytorch dict
																								_lowerCAmelCase    		=					np.asarray(__lowerCamelCase						) if not isinstance(__lowerCamelCase					,      np.ndarray						) else flax_tensor
																								_lowerCAmelCase    		=					torch.from_numpy(__lowerCamelCase						)
																								# remove from missing keys
																								missing_keys.remove(__lowerCamelCase						)
												else:
																		# weight is not expected by PyTorch model
																		unexpected_keys.append(__lowerCamelCase						)

						pt_model.load_state_dict(__lowerCamelCase						)

						# re-transform missing_keys to list
						_lowerCAmelCase    		=					list(__lowerCamelCase						)

						if len(__lowerCamelCase						) > 0:
												logger.warning(
												    """Some weights of the Flax model were not used when initializing the PyTorch model"""
												    f' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing'
												    f' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture'
												    """ (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"""
												    f' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect'
												    """ to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"""
												    """ FlaxBertForSequenceClassification model)."""						)
						else:
												logger.warning(f'All Flax model weights were used when initializing {pt_model.__class__.__name__}.\n'						)
						if len(__lowerCamelCase						) > 0:
												logger.warning(
												    f'Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly'
												    f' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to'
												    """ use it for predictions and inference."""						)
						else:
												logger.warning(
												    f'All the weights of {pt_model.__class__.__name__} were initialized from the Flax model.\n'
												    """If your task is similar to the task the model of the checkpoint was trained on, """
												    f'you can already use {pt_model.__class__.__name__} for predictions without further training.'						)

						return pt_model


'''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')}""")
