




import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


__magic_name__  :  List[str]					=       {
    """cola""": 2,
    """mnli""": 3,
    """mrpc""": 2,
    """sst-2""": 2,
    """sts-b""": 1,
    """qqp""": 2,
    """qnli""": 2,
    """rte""": 2,
    """wnli""": 2,
}


logging.set_verbosity_info()
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase=None				):
  # Initialise PyTorch model
  lowerCAmelCase__										=      XLNetConfig.from_json_file(__lowerCAmelCase				)

  lowerCAmelCase__										=      finetuning_task.lower() if finetuning_task is not None else ''''''
  if finetuning_task in GLUE_TASKS_NUM_LABELS:
    print(F"""Building PyTorch XLNetForSequenceClassification model from configuration: {config}"""				)
    lowerCAmelCase__										=      finetuning_task
    lowerCAmelCase__										=      GLUE_TASKS_NUM_LABELS[finetuning_task]
    lowerCAmelCase__										=      XLNetForSequenceClassification(__lowerCAmelCase				)
  elif "squad" in finetuning_task:
    lowerCAmelCase__										=      finetuning_task
    lowerCAmelCase__										=      XLNetForQuestionAnswering(__lowerCAmelCase				)
  else:
    lowerCAmelCase__										=      XLNetLMHeadModel(__lowerCAmelCase				)

  # Load weights from tf checkpoint
  load_tf_weights_in_xlnet(__lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				)

  # Save pytorch-model
  lowerCAmelCase__										=      os.path.join(__lowerCAmelCase   , __lowerCAmelCase				)
  lowerCAmelCase__										=      os.path.join(__lowerCAmelCase   , __lowerCAmelCase				)
  print(F"""Save PyTorch model to {os.path.abspath(__lowerCAmelCase				)}"""				)
  torch.save(model.state_dict()   , __lowerCAmelCase				)
  print(F"""Save configuration file to {os.path.abspath(__lowerCAmelCase				)}"""				)
  with open(__lowerCAmelCase   , '''w'''   , encoding='''utf-8'''				) as f:
    f.write(config.to_json_string()				)


if __name__ == "__main__":
      __magic_name__  :  Dict					=       argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
      )
      parser.add_argument(
          """--xlnet_config_file""",
          default=None,
          type=str,
          required=True,
          help=(
              """The config json file corresponding to the pre-trained XLNet model. \n"""
              """This specifies the model architecture."""
          ),
      )
      parser.add_argument(
          """--pytorch_dump_folder_path""",
          default=None,
          type=str,
          required=True,
          help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
      )
      parser.add_argument(
          """--finetuning_task""",
          default=None,
          type=str,
          help="""Name of a task on which the XLNet TensorFlow model was fine-tuned""",
      )
      __magic_name__  :  Dict					=       parser.parse_args()
      print(args)

      convert_xlnet_checkpoint_to_pytorch(
          args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
      )







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)

