





from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


_SCREAMING_SNAKE_CASE      	=		logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE      	=		{
    """Helsinki-NLP/opus-mt-en-de""": """https://huggingface.co/Helsinki-NLP/opus-mt-en-de/resolve/main/config.json""",
    # See all Marian models at https://huggingface.co/models?filter=marian
}
class SCREAMING_SNAKE_CASE_						(					snake_case_					):
						__magic_name__:			Union[str, Any]       =       "marian"
						__magic_name__:			List[Any]       =       ["past_key_values"]
						__magic_name__:			Tuple       =       {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}






						def __init__(      self      :      Optional[Any]		,   _A      :      List[Any]=58101		,   _A      :      List[str]=None		,   _A      :      Tuple=1024		,   _A      :      Any=12		,   _A      :      int=4096		,   _A      :      Optional[Any]=16		,   _A      :      Tuple=12		,   _A      :      int=4096		,   _A      :      Union[str, Any]=16		,   _A      :      Dict=0.0		,   _A      :      List[Any]=0.0		,   _A      :      List[str]=True		,   _A      :      str=True		,   _A      :      List[str]="gelu"		,   _A      :      int=1024		,   _A      :      List[Any]=0.1		,   _A      :      int=0.0		,   _A      :      Union[str, Any]=0.0		,   _A      :      int=0.0_2		,   _A      :      Dict=58100		,   _A      :      Any=False		,   _A      :      Dict=58100		,   _A      :      Tuple=0		,   _A      :      Union[str, Any]=0		,   _A      :      str=True		,   **_A      :      Dict		,   )							->    List[Any]:







							"""simple docstring"""


							snake_case_		:			int											=	vocab_size
							snake_case_		:			Dict											=	decoder_vocab_size or vocab_size
							snake_case_		:			int											=	max_position_embeddings
							snake_case_		:			int											=	d_model
							snake_case_		:			Optional[int]											=	encoder_ffn_dim
							snake_case_		:			Optional[Any]											=	encoder_layers
							snake_case_		:			List[str]											=	encoder_attention_heads
							snake_case_		:			int											=	decoder_ffn_dim
							snake_case_		:			Dict											=	decoder_layers
							snake_case_		:			List[Any]											=	decoder_attention_heads
							snake_case_		:			str											=	dropout
							snake_case_		:			Optional[Any]											=	attention_dropout
							snake_case_		:			Tuple											=	activation_dropout
							snake_case_		:			Any											=	activation_function
							snake_case_		:			Optional[int]											=	init_std
							snake_case_		:			str											=	encoder_layerdrop
							snake_case_		:			Optional[int]											=	decoder_layerdrop
							snake_case_		:			int											=	use_cache
							snake_case_		:			List[str]											=	encoder_layers
							snake_case_		:			Union[str, Any]											=	scale_embedding  # scale factor will be sqrt(d_model) if True
							snake_case_		:			Optional[int]											=	share_encoder_decoder_embeddings
							super().__init__(
							    pad_token_id=_A		,   eos_token_id=_A		,   is_encoder_decoder=_A		,   decoder_start_token_id=_A		,   forced_eos_token_id=_A		,   **_A		,   )
class SCREAMING_SNAKE_CASE_						(					snake_case_					):






						@property
						# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.inputs
						def UpperCAmelCase_				(      self      :      str	)							->    Mapping[str, Mapping[int, str]]:







							"""simple docstring"""


							if self.task in ["default", "seq2seq-lm"]:
								snake_case_		:			List[Any]											=	OrderedDict(
								    [
								        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
								        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
								    ]	)

								if self.use_past:
									snake_case_		:			int											=	{0: 'batch'}
									snake_case_		:			Dict											=	{0: 'batch', 1: 'past_decoder_sequence + sequence'}
								else:
									snake_case_		:			Optional[int]											=	{0: 'batch', 1: 'decoder_sequence'}
									snake_case_		:			List[str]											=	{0: 'batch', 1: 'decoder_sequence'}

								if self.use_past:
									self.fill_with_past_key_values_(_A		,   direction='inputs'	)
							elif self.task == "causal-lm":
								# TODO: figure this case out.
								snake_case_		:			List[str]											=	OrderedDict(
								    [
								        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
								        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
								    ]	)
								if self.use_past:
									snake_case_						,snake_case_		:			int											=	self.num_layers
									for i in range(_A	):
										snake_case_		:			Tuple											=	{0: 'batch', 2: 'past_sequence + sequence'}
										snake_case_		:			Tuple											=	{0: 'batch', 2: 'past_sequence + sequence'}
							else:
								snake_case_		:			Optional[Any]											=	OrderedDict(
								    [
								        ('input_ids', {0: 'batch', 1: 'encoder_sequence'}),
								        ('attention_mask', {0: 'batch', 1: 'encoder_sequence'}),
								        ('decoder_input_ids', {0: 'batch', 1: 'decoder_sequence'}),
								        ('decoder_attention_mask', {0: 'batch', 1: 'decoder_sequence'}),
								    ]	)

							return common_inputs






						@property
						# Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
						def UpperCAmelCase_				(      self      :      Union[str, Any]	)							->    Mapping[str, Mapping[int, str]]:







							"""simple docstring"""


							if self.task in ["default", "seq2seq-lm"]:
								snake_case_		:			Any											=	super().outputs
							else:
								snake_case_		:			int											=	super(_A		,   self	).outputs
								if self.use_past:
									snake_case_						,snake_case_		:			Optional[int]											=	self.num_layers
									for i in range(_A	):
										snake_case_		:			Optional[Any]											=	{0: 'batch', 2: 'past_sequence + sequence'}
										snake_case_		:			Optional[int]											=	{0: 'batch', 2: 'past_sequence + sequence'}
							return common_outputs






						def UpperCAmelCase_				(      self      :      Tuple		,   _A      :      PreTrainedTokenizer		,   _A      :      int = -1		,   _A      :      int = -1		,   _A      :      bool = False		,   _A      :      Optional[TensorType] = None		,   )							->    Mapping[str, Any]:







							"""simple docstring"""


							snake_case_		:			Optional[int]											=	self._generate_dummy_inputs_for_encoder_and_decoder(
							    _A		,   _A		,   _A		,   _A		,   _A	)

							# Generate decoder inputs
							snake_case_		:			Optional[Any]											=	seq_length if not self.use_past else 1
							snake_case_		:			Optional[int]											=	self._generate_dummy_inputs_for_encoder_and_decoder(
							    _A		,   _A		,   _A		,   _A		,   _A	)
							snake_case_		:			int											=	{F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
							snake_case_		:			Dict											=	dict(**_A		,   **_A	)

							if self.use_past:
								if not is_torch_available():
									raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'	)
								else:
									import torch
								snake_case_						,snake_case_		:			Any											=	common_inputs['input_ids'].shape
								snake_case_		:			List[Any]											=	common_inputs['decoder_input_ids'].shape[1]
								snake_case_						,snake_case_		:			str											=	self.num_attention_heads
								snake_case_		:			Dict											=	(
								    batch,
								    num_encoder_attention_heads,
								    encoder_seq_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)
								snake_case_		:			Union[str, Any]											=	decoder_seq_length + 3
								snake_case_		:			Tuple											=	(
								    batch,
								    num_decoder_attention_heads,
								    decoder_past_length,
								    self._config.hidden_size // num_decoder_attention_heads,
								)

								snake_case_		:			Dict											=	torch.cat(
								    [common_inputs['decoder_attention_mask'], torch.ones(_A		,   _A	)]		,   dim=1	)

								snake_case_		:			Optional[Any]											=	[]
								# If the number of encoder and decoder layers are present in the model configuration, both are considered
								snake_case_						,snake_case_		:			List[str]											=	self.num_layers
								snake_case_		:			Optional[Any]											=	min(_A		,   _A	)
								snake_case_		:			str											=	max(_A		,   _A	) - min_num_layers
								snake_case_		:			str											=	'encoder' if num_encoder_layers > num_decoder_layers else 'decoder'

								for _ in range(_A	):
									common_inputs["past_key_values"].append(
									    (
									        torch.zeros(_A	),
									        torch.zeros(_A	),
									        torch.zeros(_A	),
									        torch.zeros(_A	),
									    )	)
								# TODO: test this.
								snake_case_		:			Any											=	encoder_shape if remaining_side_name == 'encoder' else decoder_shape
								for _ in range(_A		,   _A	):
									common_inputs["past_key_values"].append((torch.zeros(_A	), torch.zeros(_A	))	)
							return common_inputs






						def UpperCAmelCase_				(      self      :      Optional[int]		,   _A      :      PreTrainedTokenizer		,   _A      :      int = -1		,   _A      :      int = -1		,   _A      :      bool = False		,   _A      :      Optional[TensorType] = None		,   )							->    Mapping[str, Any]:







							"""simple docstring"""


							snake_case_		:			Union[str, Any]											=	self._generate_dummy_inputs_for_encoder_and_decoder(
							    _A		,   _A		,   _A		,   _A		,   _A	)

							if self.use_past:
								if not is_torch_available():
									raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'	)
								else:
									import torch
								snake_case_						,snake_case_		:			Dict											=	common_inputs['input_ids'].shape
								# Not using the same length for past_key_values
								snake_case_		:			Optional[int]											=	seqlen + 2
								snake_case_						,snake_case_		:			Union[str, Any]											=	self.num_layers
								snake_case_						,snake_case_		:			Dict											=	self.num_attention_heads
								snake_case_		:			Union[str, Any]											=	(
								    batch,
								    num_encoder_attention_heads,
								    past_key_values_length,
								    self._config.hidden_size // num_encoder_attention_heads,
								)

								snake_case_		:			str											=	common_inputs['attention_mask'].dtype
								snake_case_		:			int											=	torch.cat(
								    [common_inputs['attention_mask'], torch.ones(_A		,   _A		,   dtype=_A	)]		,   dim=1	)
								snake_case_		:			List[Any]											=	[
								    (torch.zeros(_A	), torch.zeros(_A	)) for _ in range(_A	)
								]
							return common_inputs






						def UpperCAmelCase_				(      self      :      str		,   _A      :      PreTrainedTokenizer		,   _A      :      int = -1		,   _A      :      int = -1		,   _A      :      bool = False		,   _A      :      Optional[TensorType] = None		,   )							->    Mapping[str, Any]:







							"""simple docstring"""


							snake_case_		:			Optional[int]											=	compute_effective_axis_dimension(
							    _A		,   fixed_dimension=OnnxConfig.default_fixed_batch		,   num_token_to_add=0	)

							# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
							snake_case_		:			Tuple											=	tokenizer.num_special_tokens_to_add(_A	)
							snake_case_		:			List[str]											=	compute_effective_axis_dimension(
							    _A		,   fixed_dimension=OnnxConfig.default_fixed_sequence		,   num_token_to_add=_A	)

							# Generate dummy inputs according to compute batch and sequence
							snake_case_		:			Dict											=	[' '.join([tokenizer.unk_token]	) * seq_length] * batch_size
							snake_case_		:			Union[str, Any]											=	dict(tokenizer(_A		,   return_tensors=_A	)	)
							return common_inputs






						def UpperCAmelCase_				(      self      :      Optional[int]		,   _A      :      PreTrainedTokenizer		,   _A      :      int = -1		,   _A      :      int = -1		,   _A      :      bool = False		,   _A      :      Optional[TensorType] = None		,   )							->    Mapping[str, Any]:







							"""simple docstring"""


							if self.task in ["default", "seq2seq-lm"]:
								snake_case_		:			Any											=	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
								    _A		,   batch_size=_A		,   seq_length=_A		,   is_pair=_A		,   framework=_A	)

							else:
								snake_case_		:			int											=	self._generate_dummy_inputs_for_causal_lm(
								    _A		,   batch_size=_A		,   seq_length=_A		,   is_pair=_A		,   framework=_A	)

							return common_inputs






						def UpperCAmelCase_				(      self      :      Any		,   _A      :      Tuple		,   _A      :      Tuple		,   _A      :      Union[str, Any]		,   _A      :      List[str]	)							->    Optional[int]:







							"""simple docstring"""


							if self.task in ["default", "seq2seq-lm"]:
								snake_case_		:			List[Any]											=	super()._flatten_past_key_values_(_A		,   _A		,   _A		,   _A	)
							else:
								snake_case_		:			Any											=	super(_A		,   self	)._flatten_past_key_values_(
								    _A		,   _A		,   _A		,   _A	)






						@property
						def UpperCAmelCase_				(      self      :      Dict	)							->    float:







							"""simple docstring"""


							return 1E-4








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

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

						_SCREAMING_SNAKE_CASE      	=		F'''https://www.google.com/search?q={query}&num=100'''

						_SCREAMING_SNAKE_CASE      	=		requests.get(
						    url,
						    headers={"""User-Agent""": str(UserAgent().random)},
						)

						try:
												_SCREAMING_SNAKE_CASE      	=		(
												    BeautifulSoup(res.text, """html.parser""")
												    .find("""div""", attrs={"""class""": """yuRUbf"""})
												    .find("""a""")
												    .get("""href""")
												)

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

						webbrowser.open(link)

