





import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


_lowerCamelCase :    List[str]  							= '''
@inproceedings{xu-etal-2016-optimizing,
    title = {Optimizing Statistical Machine Translation for Text Simplification},
    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},
    journal = {Transactions of the Association for Computational Linguistics},
    volume = {4},
    year={2016},
    url = {https://www.aclweb.org/anthology/Q16-1029},
    pages = {401--415
},
@inproceedings{post-2018-call,
    title = "A Call for Clarity in Reporting {BLEU} Scores",
    author = "Post, Matt",
    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",
    month = oct,
    year = "2018",
    address = "Belgium, Brussels",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-6319",
    pages = "186--191",
}
'''

_lowerCamelCase :    Union[str, Any]  							= '''\
WIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU
It can be used to evaluate the quality of machine-generated texts.
'''


_lowerCamelCase :    Optional[Any]  							= '''
Calculates sari score (between 0 and 100) given a list of source and predicted
sentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.
Args:
    sources: list of source sentences where each sentence should be a string.
    predictions: list of predicted sentences where each sentence should be a string.
    references: list of lists of reference sentences where each sentence should be a string.
Returns:
    sari: sari score
    sacrebleu: sacrebleu score
    exact: exact score

Examples:
    >>> sources=["About 95 species are currently accepted ."]
    >>> predictions=["About 95 you now get in ."]
    >>> references=[["About 95 species are currently known ."]]
    >>> wiki_split = datasets.load_metric("wiki_split")
    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)
    >>> print(results)
    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}
'''




def _a (  SCREAMING_SNAKE_CASE__      :  Any       )	->    Union[str, Any]:

							'''simple docstring'''






							def remove_articles(SCREAMING_SNAKE_CASE__      :  Dict       ):
														SCREAMING_SNAKE_CASE__       :      Any     =						re.compile(R"\b(a|an|the)\b"			,				re.UNICODE       )
														return re.sub(SCREAMING_SNAKE_CASE__			,				" "			,				SCREAMING_SNAKE_CASE__       )

							def white_space_fix(SCREAMING_SNAKE_CASE__      :  Optional[Any]       ):
														return " ".join(text.split()       )

							def remove_punc(SCREAMING_SNAKE_CASE__      :  Union[str, Any]       ):
														SCREAMING_SNAKE_CASE__       :      List[str]     =						set(string.punctuation       )
														return "".join(ch for ch in text if ch not in exclude       )

							def lower(SCREAMING_SNAKE_CASE__      :  int       ):
														return text.lower()

							return white_space_fix(remove_articles(remove_punc(lower(SCREAMING_SNAKE_CASE__       )       )       )       )




def _a (  SCREAMING_SNAKE_CASE__      :  Dict			,				SCREAMING_SNAKE_CASE__      :  Dict       )	->    int:

							'''simple docstring'''






							return int(normalize_answer(SCREAMING_SNAKE_CASE__       ) == normalize_answer(SCREAMING_SNAKE_CASE__       )       )




def _a (  SCREAMING_SNAKE_CASE__      :  Union[str, Any]			,				SCREAMING_SNAKE_CASE__      :  Dict       )	->    int:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      List[str]     =						[any(compute_exact(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       ) for ref in refs       ) for pred, refs in zip(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )]
							return (sum(SCREAMING_SNAKE_CASE__       ) / len(SCREAMING_SNAKE_CASE__       )) * 1_00




def _a (  SCREAMING_SNAKE_CASE__      :  Union[str, Any]			,				SCREAMING_SNAKE_CASE__      :  Optional[Any]			,				SCREAMING_SNAKE_CASE__      :  Optional[int]			,				SCREAMING_SNAKE_CASE__      :  int       )	->    int:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      List[Any]     =						[rgram for rgrams in rgramslist for rgram in rgrams]
							SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						Counter(SCREAMING_SNAKE_CASE__       )

							SCREAMING_SNAKE_CASE__       :      Any     =						Counter(SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      int     =						Counter()
							for sgram, scount in sgramcounter.items():
														SCREAMING_SNAKE_CASE__       :      int     =						scount * numref

							SCREAMING_SNAKE_CASE__       :      int     =						Counter(SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      Any     =						Counter()
							for cgram, ccount in cgramcounter.items():
														SCREAMING_SNAKE_CASE__       :      Any     =						ccount * numref

							# KEEP
							SCREAMING_SNAKE_CASE__       :      Dict     =						sgramcounter_rep & cgramcounter_rep
							SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						keepgramcounter_rep & rgramcounter
							SCREAMING_SNAKE_CASE__       :      Optional[int]     =						sgramcounter_rep & rgramcounter

							SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						0
							SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						0
							for keepgram in keepgramcountergood_rep:
														keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
														# Fix an alleged bug [2] in the keep score computation.
														# keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
														keeptmpscorea += keepgramcountergood_rep[keepgram]
							# Define 0/0=1 instead of 0 to give higher scores for predictions that match
							#      a target exactly.
							SCREAMING_SNAKE_CASE__       :      List[str]     =						1
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						1
							if len(SCREAMING_SNAKE_CASE__       ) > 0:
														SCREAMING_SNAKE_CASE__       :      str     =						keeptmpscorea / len(SCREAMING_SNAKE_CASE__       )
							if len(SCREAMING_SNAKE_CASE__       ) > 0:
														# Fix an alleged bug [2] in the keep score computation.
														# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						keeptmpscorea / sum(keepgramcounterall_rep.values()       )
							SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						0
							if keepscore_precision > 0 or keepscore_recall > 0:
														SCREAMING_SNAKE_CASE__       :      str     =						2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

							# DELETION
							SCREAMING_SNAKE_CASE__       :      Dict     =						sgramcounter_rep - cgramcounter_rep
							SCREAMING_SNAKE_CASE__       :      int     =						delgramcounter_rep - rgramcounter
							SCREAMING_SNAKE_CASE__       :      Tuple     =						sgramcounter_rep - rgramcounter
							SCREAMING_SNAKE_CASE__       :      List[str]     =						0
							SCREAMING_SNAKE_CASE__       :      List[str]     =						0
							for delgram in delgramcountergood_rep:
														deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
														deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
							# Define 0/0=1 instead of 0 to give higher scores for predictions that match
							# a target exactly.
							SCREAMING_SNAKE_CASE__       :      Tuple     =						1
							if len(SCREAMING_SNAKE_CASE__       ) > 0:
														SCREAMING_SNAKE_CASE__       :      Tuple     =						deltmpscorea / len(SCREAMING_SNAKE_CASE__       )

							# ADDITION
							SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						set(SCREAMING_SNAKE_CASE__       ) - set(SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      Dict     =						set(SCREAMING_SNAKE_CASE__       ) & set(SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      Optional[int]     =						set(SCREAMING_SNAKE_CASE__       ) - set(SCREAMING_SNAKE_CASE__       )

							SCREAMING_SNAKE_CASE__       :      List[str]     =						0
							for addgram in addgramcountergood:
														addtmpscore += 1

							# Define 0/0=1 instead of 0 to give higher scores for predictions that match
							# a target exactly.
							SCREAMING_SNAKE_CASE__       :      Optional[int]     =						1
							SCREAMING_SNAKE_CASE__       :      Tuple     =						1
							if len(SCREAMING_SNAKE_CASE__       ) > 0:
														SCREAMING_SNAKE_CASE__       :      Dict     =						addtmpscore / len(SCREAMING_SNAKE_CASE__       )
							if len(SCREAMING_SNAKE_CASE__       ) > 0:
														SCREAMING_SNAKE_CASE__       :      Tuple     =						addtmpscore / len(SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						0
							if addscore_precision > 0 or addscore_recall > 0:
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

							return (keepscore, delscore_precision, addscore)




def _a (  SCREAMING_SNAKE_CASE__      :  List[str]			,				SCREAMING_SNAKE_CASE__      :  Dict			,				SCREAMING_SNAKE_CASE__      :  str       )	->    Any:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						len(SCREAMING_SNAKE_CASE__       )

							SCREAMING_SNAKE_CASE__       :      Dict     =						ssent.split(" "       )
							SCREAMING_SNAKE_CASE__       :      str     =						csent.split(" "       )
							SCREAMING_SNAKE_CASE__       :      str     =						[]
							SCREAMING_SNAKE_CASE__       :      Tuple     =						[]
							SCREAMING_SNAKE_CASE__       :      int     =						[]
							SCREAMING_SNAKE_CASE__       :      int     =						[]
							SCREAMING_SNAKE_CASE__       :      str     =						[]
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						[]

							SCREAMING_SNAKE_CASE__       :      Any     =						[]
							SCREAMING_SNAKE_CASE__       :      List[str]     =						[]
							SCREAMING_SNAKE_CASE__       :      List[str]     =						[]
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						[]
							for rsent in rsents:
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						rsent.split(" "       )
														SCREAMING_SNAKE_CASE__       :      Tuple     =						[]
														SCREAMING_SNAKE_CASE__       :      Dict     =						[]
														SCREAMING_SNAKE_CASE__       :      int     =						[]
														ragramslist.append(SCREAMING_SNAKE_CASE__       )
														for i in range(0			,				len(SCREAMING_SNAKE_CASE__       ) - 1       ):
																					if i < len(SCREAMING_SNAKE_CASE__       ) - 1:
																												SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						ragrams[i] + " " + ragrams[i + 1]
																												ragrams.append(SCREAMING_SNAKE_CASE__       )
																					if i < len(SCREAMING_SNAKE_CASE__       ) - 2:
																												SCREAMING_SNAKE_CASE__       :      List[str]     =						ragrams[i] + " " + ragrams[i + 1] + " " + ragrams[i + 2]
																												ragrams.append(SCREAMING_SNAKE_CASE__       )
																					if i < len(SCREAMING_SNAKE_CASE__       ) - 3:
																												SCREAMING_SNAKE_CASE__       :      Dict     =						ragrams[i] + " " + ragrams[i + 1] + " " + ragrams[i + 2] + " " + ragrams[i + 3]
																												ragrams.append(SCREAMING_SNAKE_CASE__       )
														ragramslist.append(SCREAMING_SNAKE_CASE__       )
														ragramslist.append(SCREAMING_SNAKE_CASE__       )
														ragramslist.append(SCREAMING_SNAKE_CASE__       )

							for i in range(0			,				len(SCREAMING_SNAKE_CASE__       ) - 1       ):
														if i < len(SCREAMING_SNAKE_CASE__       ) - 1:
																					SCREAMING_SNAKE_CASE__       :      Dict     =						sagrams[i] + " " + sagrams[i + 1]
																					sagrams.append(SCREAMING_SNAKE_CASE__       )
														if i < len(SCREAMING_SNAKE_CASE__       ) - 2:
																					SCREAMING_SNAKE_CASE__       :      Tuple     =						sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2]
																					sagrams.append(SCREAMING_SNAKE_CASE__       )
														if i < len(SCREAMING_SNAKE_CASE__       ) - 3:
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						sagrams[i] + " " + sagrams[i + 1] + " " + sagrams[i + 2] + " " + sagrams[i + 3]
																					sagrams.append(SCREAMING_SNAKE_CASE__       )

							for i in range(0			,				len(SCREAMING_SNAKE_CASE__       ) - 1       ):
														if i < len(SCREAMING_SNAKE_CASE__       ) - 1:
																					SCREAMING_SNAKE_CASE__       :      Any     =						cagrams[i] + " " + cagrams[i + 1]
																					cagrams.append(SCREAMING_SNAKE_CASE__       )
														if i < len(SCREAMING_SNAKE_CASE__       ) - 2:
																					SCREAMING_SNAKE_CASE__       :      Dict     =						cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2]
																					cagrams.append(SCREAMING_SNAKE_CASE__       )
														if i < len(SCREAMING_SNAKE_CASE__       ) - 3:
																					SCREAMING_SNAKE_CASE__       :      List[Any]     =						cagrams[i] + " " + cagrams[i + 1] + " " + cagrams[i + 2] + " " + cagrams[i + 3]
																					cagrams.append(SCREAMING_SNAKE_CASE__       )

							((SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__))       :      Tuple     =						SARIngram(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )
							((SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__))       :      Union[str, Any]     =						SARIngram(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )
							((SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__))       :      List[Any]     =						SARIngram(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )
							((SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__)   ,(SCREAMING_SNAKE_CASE__))       :      List[str]     =						SARIngram(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )
							SCREAMING_SNAKE_CASE__       :      str     =						sum([keepascore, keepascore, keepascore, keepascore]       ) / 4
							SCREAMING_SNAKE_CASE__       :      Any     =						sum([delascore, delascore, delascore, delascore]       ) / 4
							SCREAMING_SNAKE_CASE__       :      Optional[int]     =						sum([addascore, addascore, addascore, addascore]       ) / 4
							SCREAMING_SNAKE_CASE__       :      Optional[int]     =						(avgkeepscore + avgdelscore + avgaddscore) / 3
							return finalscore




def _a (  SCREAMING_SNAKE_CASE__      :  str			,				SCREAMING_SNAKE_CASE__      :  bool = True			,				SCREAMING_SNAKE_CASE__      :  str = "13a"			,				SCREAMING_SNAKE_CASE__      :  bool = True       )	->    List[str]:

							'''simple docstring'''






							if lowercase:
														SCREAMING_SNAKE_CASE__       :      Dict     =						sentence.lower()

							if tokenizer in ["13a", "intl"]:
														if version.parse(sacrebleu.__version__       ).major >= 2:
																					SCREAMING_SNAKE_CASE__       :      Tuple     =						sacrebleu.metrics.bleu._get_tokenizer(SCREAMING_SNAKE_CASE__       )()(SCREAMING_SNAKE_CASE__       )
														else:
																					SCREAMING_SNAKE_CASE__       :      List[str]     =						sacrebleu.TOKENIZERS[tokenizer]()(SCREAMING_SNAKE_CASE__       )
							elif tokenizer == "moses":
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						sacremoses.MosesTokenizer().tokenize(SCREAMING_SNAKE_CASE__			,				return_str=SCREAMING_SNAKE_CASE__			,				escape=SCREAMING_SNAKE_CASE__       )
							elif tokenizer == "penn":
														SCREAMING_SNAKE_CASE__       :      Dict     =						sacremoses.MosesTokenizer().penn_tokenize(SCREAMING_SNAKE_CASE__			,				return_str=SCREAMING_SNAKE_CASE__       )
							else:
														SCREAMING_SNAKE_CASE__       :      Dict     =						sentence

							if not return_str:
														SCREAMING_SNAKE_CASE__       :      str     =						normalized_sent.split()

							return normalized_sent




def _a (  SCREAMING_SNAKE_CASE__      :  Union[str, Any]			,				SCREAMING_SNAKE_CASE__      :  Any			,				SCREAMING_SNAKE_CASE__      :  int       )	->    Dict:

							'''simple docstring'''






							if not (len(SCREAMING_SNAKE_CASE__       ) == len(SCREAMING_SNAKE_CASE__       ) == len(SCREAMING_SNAKE_CASE__       )):
														raise ValueError("Sources length must match predictions and references lengths."       )
							SCREAMING_SNAKE_CASE__       :      List[str]     =						0
							for src, pred, refs in zip(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       ):
														sari_score += SARIsent(normalize(SCREAMING_SNAKE_CASE__       )			,				normalize(SCREAMING_SNAKE_CASE__       )			,				[normalize(SCREAMING_SNAKE_CASE__       ) for sent in refs]       )
							SCREAMING_SNAKE_CASE__       :      int     =						sari_score / len(SCREAMING_SNAKE_CASE__       )
							return 1_00 * sari_score




def _a (  SCREAMING_SNAKE_CASE__      :  int			,				SCREAMING_SNAKE_CASE__      :  Optional[int]			,				SCREAMING_SNAKE_CASE__      :  Tuple="exp"			,				SCREAMING_SNAKE_CASE__      :  Any=None			,				SCREAMING_SNAKE_CASE__      :  Optional[Any]=False			,				SCREAMING_SNAKE_CASE__      :  Any=False			,				SCREAMING_SNAKE_CASE__      :  Optional[Any]=False			,				)	->    Optional[int]:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      Dict     =						len(references[0]       )
							if any(len(SCREAMING_SNAKE_CASE__       ) != references_per_prediction for refs in references       ):
														raise ValueError("Sacrebleu requires the same number of references for each prediction"       )
							SCREAMING_SNAKE_CASE__       :      List[str]     =						[[refs[i] for refs in references] for i in range(SCREAMING_SNAKE_CASE__       )]
							SCREAMING_SNAKE_CASE__       :      str     =						sacrebleu.corpus_bleu(
							    SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				smooth_method=SCREAMING_SNAKE_CASE__			,				smooth_value=SCREAMING_SNAKE_CASE__			,				force=SCREAMING_SNAKE_CASE__			,				lowercase=SCREAMING_SNAKE_CASE__			,				use_effective_order=SCREAMING_SNAKE_CASE__			,				)
							return output.score







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,     _KWARGS_DESCRIPTION      )
class 						lowerCamelCase       (datasets.Metric      ):







							"""simple docstring"""




							def  A_     ( self     :					Dict						)				->			int:





														"""simple docstring"""
														return datasets.MetricInfo(
														    description=_DESCRIPTION,			citation=_CITATION,			inputs_description=_KWARGS_DESCRIPTION,			features=datasets.Features(
														        {
														            "predictions": datasets.Value("string",			id="sequence"						),
														            "references": datasets.Sequence(datasets.Value("string",			id="sequence"						),			id="references"						),
														        }						),			codebase_urls=[
														        "https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py",
														        "https://github.com/cocoxu/simplification/blob/master/SARI.py",
														        "https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py",
														        "https://github.com/mjpost/sacreBLEU",
														    ],			reference_urls=[
														        "https://www.aclweb.org/anthology/Q16-1029.pdf",
														        "https://github.com/mjpost/sacreBLEU",
														        "https://en.wikipedia.org/wiki/BLEU",
														        "https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213",
														    ],			)






							def  A_     ( self     :					Any,			_UpperCAmelCase     :					str,			_UpperCAmelCase     :					Optional[Any],			_UpperCAmelCase     :					int						)				->			str:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						{}
														result.update({"sari": compute_sari(sources=_UpperCAmelCase,			predictions=_UpperCAmelCase,			references=_UpperCAmelCase						)}						)
														result.update({"sacrebleu": compute_sacrebleu(predictions=_UpperCAmelCase,			references=_UpperCAmelCase						)}						)
														result.update({"exact": compute_em(predictions=_UpperCAmelCase,			references=_UpperCAmelCase						)}						)
														return result













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__":
		_lowerCamelCase :    Union[str, Any]  							= '''%20'''.join(argv[1:]) if len(argv) > 1 else quote(str(input('''Search: ''')))

		print('''Googling.....''')

		_lowerCamelCase :    Any  							= f"https://www.google.com/search?q={query}&num=100"

		_lowerCamelCase :    Optional[Any]  							= requests.get(
		    url,
		    headers={'''User-Agent''': str(UserAgent().random)},
		)

		try:
				_lowerCamelCase :    Union[str, Any]  							= (
				    BeautifulSoup(res.text, '''html.parser''')
				    .find('''div''', attrs={'''class''': '''yuRUbf'''})
				    .find('''a''')
				    .get('''href''')
				)

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

		webbrowser.open(link)






