




import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import RegNetForImageClassification, RegNetModel
			from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import AutoImageProcessor






class  __magic_name__						:
				'''simple docstring'''







				def __init__(							self:   int		,					_lowerCamelCase:   List[str]		,					_lowerCamelCase:   List[Any]=3		,					_lowerCamelCase:   Union[str, Any]=32		,					_lowerCamelCase:   List[Any]=3		,					_lowerCamelCase:   Tuple=10		,					_lowerCamelCase:   Optional[Any]=[10, 20, 30, 40]		,					_lowerCamelCase:   List[str]=[1, 1, 2, 1]		,					_lowerCamelCase:   str=True		,					_lowerCamelCase:   List[Any]=True		,					_lowerCamelCase:   str="relu"		,					_lowerCamelCase:   Optional[Any]=3		,					_lowerCamelCase:   Union[str, Any]=None		,					):
											SCREAMING_SNAKE_CASE_   	=    parent
											SCREAMING_SNAKE_CASE_   	=    batch_size
											SCREAMING_SNAKE_CASE_   	=    image_size
											SCREAMING_SNAKE_CASE_   	=    num_channels
											SCREAMING_SNAKE_CASE_   	=    embeddings_size
											SCREAMING_SNAKE_CASE_   	=    hidden_sizes
											SCREAMING_SNAKE_CASE_   	=    depths
											SCREAMING_SNAKE_CASE_   	=    is_training
											SCREAMING_SNAKE_CASE_   	=    use_labels
											SCREAMING_SNAKE_CASE_   	=    hidden_act
											SCREAMING_SNAKE_CASE_   	=    num_labels
											SCREAMING_SNAKE_CASE_   	=    scope
											SCREAMING_SNAKE_CASE_   	=    len(_lowerCamelCase		)


				def     _A							(							self:   Optional[int]		):
											SCREAMING_SNAKE_CASE_   	=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

											SCREAMING_SNAKE_CASE_   	=    None
											if self.use_labels:
																		SCREAMING_SNAKE_CASE_   	=    ids_tensor([self.batch_size]		,					self.num_labels		)

											SCREAMING_SNAKE_CASE_   	=    self.get_config()

											return config, pixel_values, labels


				def     _A							(							self:   Tuple		):
											return RegNetConfig(
											    num_channels=self.num_channels		,					embeddings_size=self.embeddings_size		,					hidden_sizes=self.hidden_sizes		,					depths=self.depths		,					hidden_act=self.hidden_act		,					num_labels=self.num_labels		,					)


				def     _A							(							self:   Tuple		,					_lowerCamelCase:   List[str]		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   int		):
											SCREAMING_SNAKE_CASE_   	=    RegNetModel(config=_lowerCamelCase		)
											model.to(_lowerCamelCase		)
											model.eval()
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											# expected last hidden states: B, C, H // 32, W // 32
											self.parent.assertEqual(
											    result.last_hidden_state.shape		,					(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)		,					)


				def     _A							(							self:   Union[str, Any]		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    self.num_labels
											SCREAMING_SNAKE_CASE_   	=    RegNetForImageClassification(_lowerCamelCase		)
											model.to(_lowerCamelCase		)
											model.eval()
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		,					labels=_lowerCamelCase		)
											self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)		)





				def     _A							(							self:   Dict		):
											SCREAMING_SNAKE_CASE_   	=    self.prepare_config_and_inputs()
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    config_and_inputs
											SCREAMING_SNAKE_CASE_   	=    {'''pixel_values''': pixel_values}
											return config, inputs_dict






@require_torch
class  __magic_name__						(  __UpperCAmelCase    ,  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Any	      =					(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
				SCREAMING_SNAKE_CASE__					:							List[str]	      =					(
				    {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
				    if is_torch_available()
				    else {}
				)

				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					False
				SCREAMING_SNAKE_CASE__					:							Optional[Any]	      =					False
				SCREAMING_SNAKE_CASE__					:							Optional[Any]	      =					False
				SCREAMING_SNAKE_CASE__					:							Tuple	      =					False


				def     _A							(							self:   Any		):
											SCREAMING_SNAKE_CASE_   	=    RegNetModelTester(self		)
											SCREAMING_SNAKE_CASE_   	=    ConfigTester(self		,					config_class=_lowerCamelCase		,					has_text_modality=_lowerCamelCase		)


				def     _A							(							self:   List[Any]		):
											self.create_and_test_config_common_properties()
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()


				def     _A							(							self:   List[Any]		):
											return


				@unittest.skip(reason='''RegNet does not use inputs_embeds'''		)
				def     _A							(							self:   Union[str, Any]		):
											pass


				@unittest.skip(reason='''RegNet does not support input and output embeddings'''		)
				def     _A							(							self:   Optional[Any]		):
											pass


				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
																		SCREAMING_SNAKE_CASE_   	=    inspect.signature(model.forward		)
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		SCREAMING_SNAKE_CASE_   	=    [*signature.parameters.keys()]

																		SCREAMING_SNAKE_CASE_   	=    ['''pixel_values''']
																		self.assertListEqual(arg_names[:1]		,					_lowerCamelCase		)


				def     _A							(							self:   Tuple		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_lowerCamelCase		)


				def     _A							(							self:   Dict		):
											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE_   	=    model_class(config=_lowerCamelCase		)
																		for name, module in model.named_modules():
																									if isinstance(_lowerCamelCase		,					(nn.BatchNormad, nn.GroupNorm)		):
																																self.assertTrue(
																																    torch.all(module.weight == 1		)		,					msg=f"Parameter {name} of model {model_class} seems not properly initialized"		,					)
																																self.assertTrue(
																																    torch.all(module.bias == 0		)		,					msg=f"Parameter {name} of model {model_class} seems not properly initialized"		,					)


				def     _A							(							self:   Dict		):
											def check_hidden_states_output(_lowerCamelCase:   str		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Dict		):
																		SCREAMING_SNAKE_CASE_   	=    model_class(_lowerCamelCase		)
																		model.to(_lowerCamelCase		)
																		model.eval()

																		with torch.no_grad():
																									SCREAMING_SNAKE_CASE_   	=    model(**self._prepare_for_class(_lowerCamelCase		,					_lowerCamelCase		)		)

																		SCREAMING_SNAKE_CASE_   	=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																		SCREAMING_SNAKE_CASE_   	=    self.model_tester.num_stages
																		self.assertEqual(len(_lowerCamelCase		)		,					expected_num_stages + 1		)

																		# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
																		self.assertListEqual(
																		    list(hidden_states[0].shape[-2:]		)		,					[self.model_tester.image_size // 2, self.model_tester.image_size // 2]		,					)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs_for_common()
											SCREAMING_SNAKE_CASE_   	=    ['''basic''', '''bottleneck''']
											for model_class in self.all_model_classes:
																		for layer_type in layers_type:
																									SCREAMING_SNAKE_CASE_   	=    layer_type
																									SCREAMING_SNAKE_CASE_   	=    True
																									check_hidden_states_output(_lowerCamelCase		,					_lowerCamelCase		,					_lowerCamelCase		)

																									# check that output_hidden_states also work using config
																									del inputs_dict["output_hidden_states"]
																									SCREAMING_SNAKE_CASE_   	=    True

																									check_hidden_states_output(_lowerCamelCase		,					_lowerCamelCase		,					_lowerCamelCase		)


				def     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase		)





				@slow
				def     _A							(							self:   List[str]		):
											for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE_   	=    RegNetModel.from_pretrained(_lowerCamelCase		)
																		self.assertIsNotNone(_lowerCamelCase		)






def 			a   ():
							SCREAMING_SNAKE_CASE_   	=    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
							return image






@require_torch
@require_vision
class  __magic_name__						(  unittest.TestCase):
				'''simple docstring'''







				@cached_property
				def     _A							(							self:   str		):
											return (
											    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)
											    if is_vision_available()
											    else None
											)





				@slow
				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    self.default_image_processor
											SCREAMING_SNAKE_CASE_   	=    prepare_img()
											SCREAMING_SNAKE_CASE_   	=    image_processor(images=_lowerCamelCase		,					return_tensors='''pt'''		).to(_lowerCamelCase		)

											# forward pass
											with torch.no_grad():
																		SCREAMING_SNAKE_CASE_   	=    model(**_lowerCamelCase		)

											# verify the logits
											SCREAMING_SNAKE_CASE_   	=    torch.Size((1, 10_00)		)
											self.assertEqual(outputs.logits.shape		,					_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    torch.tensor([-0.41_80, -1.50_51, -3.48_36]		).to(_lowerCamelCase		)

											self.assertTrue(torch.allclose(outputs.logits[0, :3]		,					_lowerCamelCase		,					atol=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)


