




import argparse
import json
import os

import torch

from transformers import LukeConfig, LukeModel, LukeTokenizer, RobertaTokenizer
from transformers.tokenization_utils_base import AddedToken
@torch.no_grad()
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				):
  # Load configuration defined in the metadata file
  with open(__lowerCAmelCase				) as metadata_file:
    lowerCAmelCase__										=      json.load(__lowerCAmelCase				)
  lowerCAmelCase__										=      LukeConfig(use_entity_aware_attention=__lowerCAmelCase   , **metadata['''model_config''']				)

  # Load in the weights from the checkpoint_path
  lowerCAmelCase__										=      torch.load(__lowerCAmelCase   , map_location='''cpu'''				)

  # Load the entity vocab file
  lowerCAmelCase__										=      load_entity_vocab(__lowerCAmelCase				)

  lowerCAmelCase__										=      RobertaTokenizer.from_pretrained(metadata['''model_config''']['''bert_model_name''']				)

  # Add special tokens to the token vocabulary for downstream tasks
  lowerCAmelCase__										=      AddedToken('''<ent>'''   , lstrip=__lowerCAmelCase   , rstrip=__lowerCAmelCase				)
  lowerCAmelCase__										=      AddedToken('''<ent2>'''   , lstrip=__lowerCAmelCase   , rstrip=__lowerCAmelCase				)
  tokenizer.add_special_tokens({'''additional_special_tokens''': [entity_token_a, entity_token_a]}				)
  config.vocab_size += 2

  print(F"""Saving tokenizer to {pytorch_dump_folder_path}"""				)
  tokenizer.save_pretrained(__lowerCAmelCase				)
  with open(os.path.join(__lowerCAmelCase   , LukeTokenizer.vocab_files_names['''entity_vocab_file''']				)   , '''w'''				) as f:
    json.dump(__lowerCAmelCase   , __lowerCAmelCase				)

  lowerCAmelCase__										=      LukeTokenizer.from_pretrained(__lowerCAmelCase				)

  # Initialize the embeddings of the special tokens
  lowerCAmelCase__										=      state_dict['''embeddings.word_embeddings.weight''']
  lowerCAmelCase__										=      word_emb[tokenizer.convert_tokens_to_ids(['''@''']				)[0]].unsqueeze(0				)
  lowerCAmelCase__										=      word_emb[tokenizer.convert_tokens_to_ids(['''#''']				)[0]].unsqueeze(0				)
  lowerCAmelCase__										=      torch.cat([word_emb, ent_emb, enta_emb]				)

  # Initialize the query layers of the entity-aware self-attention mechanism
  for layer_index in range(config.num_hidden_layers				):
    for matrix_name in ["query.weight", "query.bias"]:
      lowerCAmelCase__										=      F"""encoder.layer.{layer_index}.attention.self."""
      lowerCAmelCase__										=      state_dict[prefix + matrix_name]
      lowerCAmelCase__										=      state_dict[prefix + matrix_name]
      lowerCAmelCase__										=      state_dict[prefix + matrix_name]

    # Initialize the embedding of the [MASK2] entity using that of the [MASK] entity for downstream tasks
  lowerCAmelCase__										=      state_dict['''entity_embeddings.entity_embeddings.weight''']
  lowerCAmelCase__										=      entity_emb[entity_vocab['''[MASK]''']]

  lowerCAmelCase__										=      LukeModel(config=__lowerCAmelCase				).eval()

  lowerCAmelCase__				,      lowerCAmelCase__										=      model.load_state_dict(__lowerCAmelCase   , strict=__lowerCAmelCase				)
  if not (len(__lowerCAmelCase				) == 1 and missing_keys[0] == "embeddings.position_ids"):
    raise ValueError(F"""Missing keys {', '.join(__lowerCAmelCase				)}. Expected only missing embeddings.position_ids"""				)
  if not (all(key.startswith('''entity_predictions'''				) or key.startswith('''lm_head'''				) for key in unexpected_keys				)):
    raise ValueError(
        '''Unexpected keys'''
        F""" {', '.join([key for key in unexpected_keys if not (key.startswith('entity_predictions'				) or key.startswith('lm_head'				))]				)}"""				)

  # Check outputs
  lowerCAmelCase__										=      LukeTokenizer.from_pretrained(__lowerCAmelCase   , task='''entity_classification'''				)

  lowerCAmelCase__										=      (
      '''Top seed Ana Ivanovic said on Thursday she could hardly believe her luck as a fortuitous netcord helped the'''
      ''' new world number one avoid a humiliating second- round exit at Wimbledon .'''
  )
  lowerCAmelCase__										=      (39, 42)
  lowerCAmelCase__										=      tokenizer(__lowerCAmelCase   , entity_spans=[span]   , add_prefix_space=__lowerCAmelCase   , return_tensors='''pt'''				)

  lowerCAmelCase__										=      model(**__lowerCAmelCase				)

  # Verify word hidden states
  if model_size == "large":
    lowerCAmelCase__										=      torch.Size((1, 42, 10_24)				)
    lowerCAmelCase__										=      torch.tensor(
        [[0.0_133, 0.0_865, 0.0_095], [0.3_093, -0.2_576, -0.7_418], [-0.1_720, -0.2_117, -0.2_869]]				)
  else:  # base
    lowerCAmelCase__										=      torch.Size((1, 42, 7_68)				)
    lowerCAmelCase__										=      torch.tensor([[0.0_037, 0.1_368, -0.0_091], [0.1_099, 0.3_329, -0.1_095], [0.0_765, 0.5_335, 0.1_179]]				)

  if not (outputs.last_hidden_state.shape == expected_shape):
    raise ValueError(
        F"""Outputs.last_hidden_state.shape is {outputs.last_hidden_state.shape}, Expected shape is {expected_shape}"""				)
  if not torch.allclose(outputs.last_hidden_state[0, :3, :3]   , __lowerCAmelCase   , atol=1E-4				):
    raise ValueError

  # Verify entity hidden states
  if model_size == "large":
    lowerCAmelCase__										=      torch.Size((1, 1, 10_24)				)
    lowerCAmelCase__										=      torch.tensor([[0.0_466, -0.0_106, -0.0_179]]				)
  else:  # base
    lowerCAmelCase__										=      torch.Size((1, 1, 7_68)				)
    lowerCAmelCase__										=      torch.tensor([[0.1_457, 0.1_044, 0.0_174]]				)

  if not (outputs.entity_last_hidden_state.shape != expected_shape):
    raise ValueError(
        F"""Outputs.entity_last_hidden_state.shape is {outputs.entity_last_hidden_state.shape}, Expected shape is"""
        F""" {expected_shape}"""				)
  if not torch.allclose(outputs.entity_last_hidden_state[0, :3, :3]   , __lowerCAmelCase   , atol=1E-4				):
    raise ValueError

  # Finally, save our PyTorch model and tokenizer
  print('''Saving PyTorch model to {}'''.format(__lowerCAmelCase				)				)
  model.save_pretrained(__lowerCAmelCase				)
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      {}
  with open(__lowerCAmelCase   , '''r'''   , encoding='''utf-8'''				) as f:
    for index, line in enumerate(__lowerCAmelCase				):
      lowerCAmelCase__				,      lowerCAmelCase__										=      line.rstrip().split('''\t'''				)
      lowerCAmelCase__										=      index

  return entity_vocab


if __name__ == "__main__":
      __magic_name__  :  Tuple					=       argparse.ArgumentParser()
      # Required parameters
      parser.add_argument("""--checkpoint_path""", type=str, help="""Path to a pytorch_model.bin file.""")
      parser.add_argument(
          """--metadata_path""", default=None, type=str, help="""Path to a metadata.json file, defining the configuration."""
      )
      parser.add_argument(
          """--entity_vocab_path""",
          default=None,
          type=str,
          help="""Path to an entity_vocab.tsv file, containing the entity vocabulary.""",
      )
      parser.add_argument(
          """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to where to dump the output PyTorch model."""
      )
      parser.add_argument(
          """--model_size""", default="""base""", type=str, choices=["""base""", """large"""], help="""Size of the model to be converted."""
      )
      __magic_name__  :  Optional[int]					=       parser.parse_args()
      convert_luke_checkpoint(
          args.checkpoint_path,
          args.metadata_path,
          args.entity_vocab_path,
          args.pytorch_dump_folder_path,
          args.model_size,
      )







import webbrowser
from sys import argv
from urllib.parse import parse_qs, quote

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
      __magic_name__  :  List[Any]					=       """%20""".join(argv[1:]) if len(argv) > 1 else quote(str(input("""Search: """)))

      print("""Googling.....""")

      __magic_name__  :  List[Any]					=       F"https://www.google.com/search?q={query}&num=100"

      __magic_name__  :  Union[str, Any]					=       requests.get(
          url,
          headers={"""User-Agent""": str(UserAgent().random)},
      )

      try:
            __magic_name__  :  Optional[Any]					=       (
                BeautifulSoup(res.text, """html.parser""")
                .find("""div""", attrs={"""class""": """yuRUbf"""})
                .find("""a""")
                .get("""href""")
            )

      except AttributeError:
            __magic_name__  :  List[Any]					=       parse_qs(
                BeautifulSoup(res.text, """html.parser""")
                .find("""div""", attrs={"""class""": """kCrYT"""})
                .find("""a""")
                .get("""href""")
            )["""url"""][0]

      webbrowser.open(link)

