
'''simple docstring'''





import inspect
import unittest

from transformers import ResNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
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 ResNetBackbone, ResNetForImageClassification, ResNetModel
					from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor

class      lowerCAmelCase__  :






		def __init__(	self	:							Optional[Any]							,    SCREAMING_SNAKE_CASE__	:							int							,    SCREAMING_SNAKE_CASE__	:							List[str]=3							,    SCREAMING_SNAKE_CASE__	:							Dict=32							,    SCREAMING_SNAKE_CASE__	:							Dict=3							,    SCREAMING_SNAKE_CASE__	:							Optional[Any]=10							,    SCREAMING_SNAKE_CASE__	:							List[str]=[10, 20, 30, 40]							,    SCREAMING_SNAKE_CASE__	:							int=[1, 1, 2, 1]							,    SCREAMING_SNAKE_CASE__	:							Optional[int]=True							,    SCREAMING_SNAKE_CASE__	:							Optional[Any]=True							,    SCREAMING_SNAKE_CASE__	:							Dict="relu"							,    SCREAMING_SNAKE_CASE__	:							List[Any]=3							,    SCREAMING_SNAKE_CASE__	:							Any=None							,    SCREAMING_SNAKE_CASE__	:							Optional[Any]=["stage2", "stage3", "stage4"]							,    SCREAMING_SNAKE_CASE__	:							int=[2, 3, 4]							,    )  ->							str:
						__lowerCamelCase					      =			parent
						__lowerCamelCase					      =			batch_size
						__lowerCamelCase					      =			image_size
						__lowerCamelCase					      =			num_channels
						__lowerCamelCase					      =			embeddings_size
						__lowerCamelCase					      =			hidden_sizes
						__lowerCamelCase					      =			depths
						__lowerCamelCase					      =			is_training
						__lowerCamelCase					      =			use_labels
						__lowerCamelCase					      =			hidden_act
						__lowerCamelCase					      =			num_labels
						__lowerCamelCase					      =			scope
						__lowerCamelCase					      =			len(SCREAMING_SNAKE_CASE__						)
						__lowerCamelCase					      =			out_features
						__lowerCamelCase					      =			out_indices






		def 				__A (	self	:							str						)  ->							str:
						__lowerCamelCase					      =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

						__lowerCamelCase					      =			self.get_config()

						return config, pixel_values, labels






		def 				__A (	self	:							Tuple						)  ->							List[Any]:
						return ResNetConfig(
						    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							,    out_features=self.out_features							,    out_indices=self.out_indices							,    )






		def 				__A (	self	:							Tuple							,    SCREAMING_SNAKE_CASE__	:							int							,    SCREAMING_SNAKE_CASE__	:							List[str]							,    SCREAMING_SNAKE_CASE__	:							Any						)  ->							Any:
						__lowerCamelCase					      =			ResNetModel(config=SCREAMING_SNAKE_CASE__						)
						model.to(SCREAMING_SNAKE_CASE__						)
						model.eval()
						__lowerCamelCase					      =			model(SCREAMING_SNAKE_CASE__						)
						# 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]							,    SCREAMING_SNAKE_CASE__	:							str							,    SCREAMING_SNAKE_CASE__	:							List[str]							,    SCREAMING_SNAKE_CASE__	:							Any						)  ->							List[str]:
						__lowerCamelCase					      =			self.num_labels
						__lowerCamelCase					      =			ResNetForImageClassification(SCREAMING_SNAKE_CASE__						)
						model.to(SCREAMING_SNAKE_CASE__						)
						model.eval()
						__lowerCamelCase					      =			model(SCREAMING_SNAKE_CASE__							,    labels=SCREAMING_SNAKE_CASE__						)
						self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.num_labels)						)






		def 				__A (	self	:							str							,    SCREAMING_SNAKE_CASE__	:							str							,    SCREAMING_SNAKE_CASE__	:							str							,    SCREAMING_SNAKE_CASE__	:							Tuple						)  ->							Optional[Any]:
						__lowerCamelCase					      =			ResNetBackbone(config=SCREAMING_SNAKE_CASE__						)
						model.to(SCREAMING_SNAKE_CASE__						)
						model.eval()
						__lowerCamelCase					      =			model(SCREAMING_SNAKE_CASE__						)

						# verify feature maps
						self.parent.assertEqual(len(result.feature_maps						)							,    len(config.out_features						)						)
						self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,    [self.batch_size, self.hidden_sizes[1], 4, 4]						)

						# verify channels
						self.parent.assertEqual(len(model.channels						)							,    len(config.out_features						)						)
						self.parent.assertListEqual(model.channels							,    config.hidden_sizes[1:]						)

						# verify backbone works with out_features=None
						__lowerCamelCase					      =			None
						__lowerCamelCase					      =			ResNetBackbone(config=SCREAMING_SNAKE_CASE__						)
						model.to(SCREAMING_SNAKE_CASE__						)
						model.eval()
						__lowerCamelCase					      =			model(SCREAMING_SNAKE_CASE__						)

						# verify feature maps
						self.parent.assertEqual(len(result.feature_maps						)							,    1						)
						self.parent.assertListEqual(list(result.feature_maps[0].shape						)							,    [self.batch_size, self.hidden_sizes[-1], 1, 1]						)

						# verify channels
						self.parent.assertEqual(len(model.channels						)							,    1						)
						self.parent.assertListEqual(model.channels							,    [config.hidden_sizes[-1]]						)







		def 				__A (	self	:							Any						)  ->							Union[str, Any]:
						__lowerCamelCase					      =			self.prepare_config_and_inputs()
						__lowerCamelCase					      =			config_and_inputs
						__lowerCamelCase					      =			{"pixel_values": pixel_values}
						return config, inputs_dict





@require_torch
class      lowerCAmelCase__  (			A__						,			A__						,			unittest.TestCase    ):
		a__ :		int   						=	(
		    (
		        ResNetModel,
		        ResNetForImageClassification,
		        ResNetBackbone,
		    )
		    if is_torch_available()
		    else ()
		)
		a__ :		str   						=	(
		    {'''feature-extraction''': ResNetModel, '''image-classification''': ResNetForImageClassification}
		    if is_torch_available()
		    else {}
		)

		a__ :		List[Any]   						=	True
		a__ :		Union[str, Any]   						=	False
		a__ :		List[str]   						=	False
		a__ :		str   						=	False
		a__ :		List[str]   						=	False






		def 				__A (	self	:							Optional[int]						)  ->							Optional[Any]:
						__lowerCamelCase					      =			ResNetModelTester(self						)
						__lowerCamelCase					      =			ConfigTester(self							,    config_class=SCREAMING_SNAKE_CASE__							,    has_text_modality=SCREAMING_SNAKE_CASE__						)






		def 				__A (	self	:							Dict						)  ->							List[str]:
						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	:							int						)  ->							Dict:
						return






		@unittest.skip(reason='''ResNet does not use inputs_embeds'''						)
		def 				__A (	self	:							Tuple						)  ->							Tuple:
						pass






		@unittest.skip(reason='''ResNet does not support input and output embeddings'''						)
		def 				__A (	self	:							int						)  ->							Any:
						pass






		def 				__A (	self	:							Union[str, Any]						)  ->							str:
						__lowerCamelCase					      =			self.model_tester.prepare_config_and_inputs_for_common()

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

										__lowerCamelCase					      =			["pixel_values"]
										self.assertListEqual(arg_names[:1]							,    SCREAMING_SNAKE_CASE__						)






		def 				__A (	self	:							List[str]						)  ->							int:
						__lowerCamelCase					      =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__						)






		def 				__A (	self	:							List[Any]						)  ->							List[str]:
						__lowerCamelCase					      =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_backbone(*SCREAMING_SNAKE_CASE__						)






		def 				__A (	self	:							Any						)  ->							Dict:
						__lowerCamelCase					      =			self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
										__lowerCamelCase					      =			model_class(config=SCREAMING_SNAKE_CASE__						)
										for name, module in model.named_modules():
														if isinstance(SCREAMING_SNAKE_CASE__							,    (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	:							int						)  ->							Any:






						def check_hidden_states_output(SCREAMING_SNAKE_CASE__	:							List[Any]							,    SCREAMING_SNAKE_CASE__	:							Optional[int]							,    SCREAMING_SNAKE_CASE__	:							Optional[int]						):
										__lowerCamelCase					      =			model_class(SCREAMING_SNAKE_CASE__						)
										model.to(SCREAMING_SNAKE_CASE__						)
										model.eval()

										with torch.no_grad():
														__lowerCamelCase					      =			model(**self._prepare_for_class(SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						)						)

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

										__lowerCamelCase					      =			self.model_tester.num_stages
										self.assertEqual(len(SCREAMING_SNAKE_CASE__						)							,    expected_num_stages + 1						)

										# ResNet'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 // 4, self.model_tester.image_size // 4]							,    )

						__lowerCamelCase					      =			self.model_tester.prepare_config_and_inputs_for_common()
						__lowerCamelCase					      =			["basic", "bottleneck"]
						for model_class in self.all_model_classes:
										for layer_type in layers_type:
														__lowerCamelCase					      =			layer_type
														__lowerCamelCase					      =			True
														check_hidden_states_output(SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						)

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

														check_hidden_states_output(SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__							,    SCREAMING_SNAKE_CASE__						)






		@unittest.skip(reason='''ResNet does not use feedforward chunking'''						)
		def 				__A (	self	:							Optional[int]						)  ->							Union[str, Any]:
						pass






		def 				__A (	self	:							int						)  ->							List[Any]:
						__lowerCamelCase					      =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__						)







		@slow
		def 				__A (	self	:							Dict						)  ->							Any:






						for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										__lowerCamelCase					      =			ResNetModel.from_pretrained(SCREAMING_SNAKE_CASE__						)
										self.assertIsNotNone(SCREAMING_SNAKE_CASE__						)





def 				__magic_name__				(     )    ->     int:
				__lowerCamelCase					      =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
				return image

@require_torch
@require_vision
class      lowerCAmelCase__  (			unittest.TestCase    ):






		@cached_property
		def 				__A (	self	:							Optional[Any]						)  ->							Optional[int]:
						return (
						    AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)
						    if is_vision_available()
						    else None
						)







		@slow
		def 				__A (	self	:							Union[str, Any]						)  ->							Union[str, Any]:
						__lowerCamelCase					      =			ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(SCREAMING_SNAKE_CASE__						)

						__lowerCamelCase					      =			self.default_image_processor
						__lowerCamelCase					      =			prepare_img()
						__lowerCamelCase					      =			image_processor(images=SCREAMING_SNAKE_CASE__							,    return_tensors='''pt'''						).to(SCREAMING_SNAKE_CASE__						)

						# forward pass
						with torch.no_grad():
										__lowerCamelCase					      =			model(**SCREAMING_SNAKE_CASE__						)

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

						__lowerCamelCase					      =			torch.tensor([-11.10_69, -9.7877, -8.3777]						).to(SCREAMING_SNAKE_CASE__						)

						self.assertTrue(torch.allclose(outputs.logits[0, :3]							,    SCREAMING_SNAKE_CASE__							,    atol=1e-4						)						)





@require_torch
class      lowerCAmelCase__  (			A__						,			unittest.TestCase    ):
		a__ :		str   						=	(ResNetBackbone,) if is_torch_available() else ()
		a__ :		Any   						=	False
		a__ :		Optional[Any]   						=	ResNetConfig






		def 				__A (	self	:							Optional[int]						)  ->							Optional[int]:
						__lowerCamelCase					      =			ResNetModelTester(self						)





import bsa
import requests




def 				__magic_name__				(     __lowerCAmelCase			:		bsa.element.ResultSet							)    ->     dict[str, str]:
				return {
				    "name": soup.ha.a.text,
				    "genre": soup.find('''span'''	,						class_='''genre'''							).text.strip(),
				    "rating": soup.strong.text,
				    "page_link": f'''https://www.imdb.com{soup.a.get('href'							)}''',
				}




def 				__magic_name__				(     __lowerCAmelCase			:		int = 5							)    ->     tuple:
				__lowerCamelCase					      =			int(float(__lowerCAmelCase							)							)
				if num_movies < 1:
								return ()
				__lowerCamelCase					      =			(
				    '''https://www.imdb.com/search/title?title_type='''
				    f'''feature&sort=num_votes,desc&count={num_movies}'''
				)
				__lowerCamelCase					      =			bsa.BeautifulSoup(requests.get(__lowerCAmelCase							).content	,						'''html.parser'''							)
				return tuple(
				    get_movie_data_from_soup(__lowerCAmelCase							)
				    for movie in source.find_all('''div'''	,						class_='''lister-item mode-advanced'''							)							)


if __name__ == "__main__":
					import json

					SCREAMING_SNAKE_CASE__     :    str      							=					int(input("How many movies would you like to see? "))
					print(
					    ", ".join(
					        json.dumps(movie, indent=4) for movie in get_imdb_top_movies(num_movies)
					    )
					)



