


'''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


__magic_name__			=      logging.get_logger(__name__)




def      lowerCamelCase					(      lowerCamelCase  :      Any):
      A_						:  str          =				r"""\w+[.]\d+"""
      A_						:  int          =				re.findall(lowerCamelCase							,						lowerCamelCase)
      for pat in pats:
            A_						:  Optional[int]          =				key.replace(lowerCamelCase							,						"""_""".join(pat.split(""".""")))
      return key




def      lowerCamelCase					(      lowerCamelCase  :      Optional[Any]							,						lowerCamelCase  :      List[str]							,						lowerCamelCase  :      Optional[Any]):
      A_						:  Optional[int]          =				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)
      ):
            A_						:  Any          =				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:
            A_						:  str          =				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:
            A_						:  List[str]          =				pt_tuple_key[:-1] + ("""embedding""",)
            return renamed_pt_tuple_key, pt_tensor

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

      # linear layer
      A_						:  Optional[int]          =				pt_tuple_key[:-1] + ("""kernel""",)
      if pt_tuple_key[-1] == "weight":
            A_						:  List[str]          =				pt_tensor.T
            return renamed_pt_tuple_key, pt_tensor

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

      # old PyTorch layer norm bias
      A_						:  Union[str, Any]          =				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      lowerCamelCase					(      lowerCamelCase  :      Optional[Any]							,						lowerCamelCase  :      Tuple							,						lowerCamelCase  :      List[Any]=42):
      # Step 1: Convert pytorch tensor to numpy
      A_						:  Optional[int]          =				{k: v.numpy() for k, v in pt_state_dict.items()}

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

      A_						:  Any          =				flatten_dict(lowerCamelCase)
      A_						:  List[str]          =				{}

      # Need to change some parameters name to match Flax names
      for pt_key, pt_tensor in pt_state_dict.items():
            A_						:  Optional[int]          =				rename_key(lowerCamelCase)
            A_						:  Optional[Any]          =				tuple(renamed_pt_key.split("""."""))

            # Correctly rename weight parameters
            A_   ,					A_						:  Optional[int]          =				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
            A_						:  int          =				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.....')
     __magic_name__			=      'https://www.google.com/search?q=' + ' '.join(sys.argv[1:])
     __magic_name__			=      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(10_000):
               out_file.write(data)
     __magic_name__			=      BeautifulSoup(res.text, 'html.parser')
     __magic_name__			=      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')}""")
