



import collections
import inspect
import unittest

from transformers import SwinvaConfig
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_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch
						from torch import nn

						from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
						from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor






class    SCREAMING_SNAKE_CASE			:





							def __init__(   self		:		Tuple      ,				__lowercase		:		Tuple      ,				__lowercase		:		Optional[Any]=13      ,				__lowercase		:		Dict=32      ,				__lowercase		:		int=2      ,				__lowercase		:		str=3      ,				__lowercase		:		Optional[int]=16      ,				__lowercase		:		Any=[1, 2, 1]      ,				__lowercase		:		Optional[Any]=[2, 2, 4]      ,				__lowercase		:		Optional[int]=2      ,				__lowercase		:		Optional[int]=2.0      ,				__lowercase		:		str=True      ,				__lowercase		:		List[Any]=0.0      ,				__lowercase		:		Optional[Any]=0.0      ,				__lowercase		:		Any=0.1      ,				__lowercase		:		Tuple="gelu"      ,				__lowercase		:		List[Any]=False      ,				__lowercase		:		List[str]=True      ,				__lowercase		:		Any=0.02      ,				__lowercase		:		Dict=1E-5      ,				__lowercase		:		List[str]=True      ,				__lowercase		:		str=None      ,				__lowercase		:		Tuple=True      ,				__lowercase		:		Tuple=10      ,				__lowercase		:		Any=8      ,				):

											'''simple docstring'''
											__a       =		parent
											__a       =		batch_size
											__a       =		image_size
											__a       =		patch_size
											__a       =		num_channels
											__a       =		embed_dim
											__a       =		depths
											__a       =		num_heads
											__a       =		window_size
											__a       =		mlp_ratio
											__a       =		qkv_bias
											__a       =		hidden_dropout_prob
											__a       =		attention_probs_dropout_prob
											__a       =		drop_path_rate
											__a       =		hidden_act
											__a       =		use_absolute_embeddings
											__a       =		patch_norm
											__a       =		layer_norm_eps
											__a       =		initializer_range
											__a       =		is_training
											__a       =		scope
											__a       =		use_labels
											__a       =		type_sequence_label_size
											__a       =		encoder_stride





							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

											__a       =		None
											if self.use_labels:
															__a       =		ids_tensor([self.batch_size]      ,				self.type_sequence_label_size	)

											__a       =		self.get_config()

											return config, pixel_values, labels





							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											return SwinvaConfig(
											    image_size=self.image_size      ,				patch_size=self.patch_size      ,				num_channels=self.num_channels      ,				embed_dim=self.embed_dim      ,				depths=self.depths      ,				num_heads=self.num_heads      ,				window_size=self.window_size      ,				mlp_ratio=self.mlp_ratio      ,				qkv_bias=self.qkv_bias      ,				hidden_dropout_prob=self.hidden_dropout_prob      ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,				drop_path_rate=self.drop_path_rate      ,				hidden_act=self.hidden_act      ,				use_absolute_embeddings=self.use_absolute_embeddings      ,				path_norm=self.patch_norm      ,				layer_norm_eps=self.layer_norm_eps      ,				initializer_range=self.initializer_range      ,				encoder_stride=self.encoder_stride      ,				)





							def 						UpperCamelCase_					(   self		:		Union[str, Any]      ,				__lowercase		:		Tuple      ,				__lowercase		:		str      ,				__lowercase		:		Optional[Any]	):

											'''simple docstring'''
											__a       =		SwinvaModel(config=__lowercase	)
											model.to(__lowercase	)
											model.eval()
											__a       =		model(__lowercase	)

											__a       =		((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
											__a       =		int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

											self.parent.assertEqual(result.last_hidden_state.shape      ,				(self.batch_size, expected_seq_len, expected_dim)	)





							def 						UpperCamelCase_					(   self		:		Tuple      ,				__lowercase		:		List[Any]      ,				__lowercase		:		Union[str, Any]      ,				__lowercase		:		Union[str, Any]	):

											'''simple docstring'''
											__a       =		SwinvaForMaskedImageModeling(config=__lowercase	)
											model.to(__lowercase	)
											model.eval()
											__a       =		model(__lowercase	)
											self.parent.assertEqual(
											    result.logits.shape      ,				(self.batch_size, self.num_channels, self.image_size, self.image_size)	)

											# test greyscale images
											__a       =		1
											__a       =		SwinvaForMaskedImageModeling(__lowercase	)
											model.to(__lowercase	)
											model.eval()

											__a       =		floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
											__a       =		model(__lowercase	)
											self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, 1, self.image_size, self.image_size)	)





							def 						UpperCamelCase_					(   self		:		Optional[int]      ,				__lowercase		:		Tuple      ,				__lowercase		:		Dict      ,				__lowercase		:		int	):

											'''simple docstring'''
											__a       =		self.type_sequence_label_size
											__a       =		SwinvaForImageClassification(__lowercase	)
											model.to(__lowercase	)
											model.eval()
											__a       =		model(__lowercase      ,				labels=__lowercase	)
											self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.type_sequence_label_size)	)







							def 						UpperCamelCase_					(   self		:		Any	):

											'''simple docstring'''
											__a       =		self.prepare_config_and_inputs()
											__a     ,					__a     ,					__a       =		config_and_inputs
											__a       =		{"""pixel_values""": pixel_values}
											return config, inputs_dict






@require_torch
class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Union[str, Any]    =(
							    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
							)
							__lowerCamelCase	:	int    =(
							    {'feature-extraction': SwinvaModel, 'image-classification': SwinvaForImageClassification}
							    if is_torch_available()
							    else {}
							)

							__lowerCamelCase	:	Tuple    =False
							__lowerCamelCase	:	Tuple    =False
							__lowerCamelCase	:	Union[str, Any]    =False
							__lowerCamelCase	:	Dict    =False





							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a       =		SwinvaModelTester(self	)
											__a       =		ConfigTester(self      ,				config_class=__lowercase      ,				embed_dim=37	)





							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											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 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											__a       =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__lowercase	)





							@unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""	)
							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											pass





							@unittest.skip(reason="""Swinv2 does not use inputs_embeds"""	)
							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											pass





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															__a       =		model_class(__lowercase	)
															self.assertIsInstance(model.get_input_embeddings()      ,				(nn.Module)	)
															__a       =		model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(__lowercase      ,				nn.Linear	)	)





							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()

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

															__a       =		["""pixel_values"""]
															self.assertListEqual(arg_names[:1]      ,				__lowercase	)





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()
											__a       =		True

											for model_class in self.all_model_classes:
															__a       =		True
															__a       =		False
															__a       =		True
															__a       =		model_class(__lowercase	)
															model.to(__lowercase	)
															model.eval()
															with torch.no_grad():
																			__a       =		model(**self._prepare_for_class(__lowercase      ,				__lowercase	)	)
															__a       =		outputs.attentions
															__a       =		len(self.model_tester.depths	)
															self.assertEqual(len(__lowercase	)      ,				__lowercase	)

															# check that output_attentions also work using config
															del inputs_dict["output_attentions"]
															__a       =		True
															__a       =		config.window_size**2
															__a       =		model_class(__lowercase	)
															model.to(__lowercase	)
															model.eval()
															with torch.no_grad():
																			__a       =		model(**self._prepare_for_class(__lowercase      ,				__lowercase	)	)
															__a       =		outputs.attentions
															self.assertEqual(len(__lowercase	)      ,				__lowercase	)

															self.assertListEqual(
															    list(attentions[0].shape[-3:]	)      ,				[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,				)
															__a       =		len(__lowercase	)

															# Check attention is always last and order is fine
															__a       =		True
															__a       =		True
															__a       =		model_class(__lowercase	)
															model.to(__lowercase	)
															model.eval()
															with torch.no_grad():
																			__a       =		model(**self._prepare_for_class(__lowercase      ,				__lowercase	)	)

															if hasattr(self.model_tester      ,				"""num_hidden_states_types"""	):
																			__a       =		self.model_tester.num_hidden_states_types
															else:
																			# also another +1 for reshaped_hidden_states
																			__a       =		2
															self.assertEqual(out_len + added_hidden_states      ,				len(__lowercase	)	)

															__a       =		outputs.attentions

															self.assertEqual(len(__lowercase	)      ,				__lowercase	)

															self.assertListEqual(
															    list(self_attentions[0].shape[-3:]	)      ,				[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,				)





							def 						UpperCamelCase_					(   self		:		Tuple      ,				__lowercase		:		List[str]      ,				__lowercase		:		Tuple      ,				__lowercase		:		str      ,				__lowercase		:		Union[str, Any]	):

											'''simple docstring'''
											__a       =		model_class(__lowercase	)
											model.to(__lowercase	)
											model.eval()

											with torch.no_grad():
															__a       =		model(**self._prepare_for_class(__lowercase      ,				__lowercase	)	)

											__a       =		outputs.hidden_states

											__a       =		getattr(
											    self.model_tester      ,				"""expected_num_hidden_layers"""      ,				len(self.model_tester.depths	) + 1	)
											self.assertEqual(len(__lowercase	)      ,				__lowercase	)

											# Swinv2 has a different seq_length
											__a       =		(
											    config.patch_size
											    if isinstance(config.patch_size      ,				collections.abc.Iterable	)
											    else (config.patch_size, config.patch_size)
											)

											__a       =		(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

											self.assertListEqual(
											    list(hidden_states[0].shape[-2:]	)      ,				[num_patches, self.model_tester.embed_dim]      ,				)

											__a       =		outputs.reshaped_hidden_states
											self.assertEqual(len(__lowercase	)      ,				__lowercase	)

											__a     ,					__a     ,					__a     ,					__a       =		reshaped_hidden_states[0].shape
											__a       =		(
											    reshaped_hidden_states[0].view(__lowercase      ,				__lowercase      ,				height * width	).permute(0      ,				2      ,				1	)
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-2:]	)      ,				[num_patches, self.model_tester.embed_dim]      ,				)





							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()

											__a       =		(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size      ,				collections.abc.Iterable	)
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)

											for model_class in self.all_model_classes:
															__a       =		True
															self.check_hidden_states_output(__lowercase      ,				__lowercase      ,				__lowercase      ,				__lowercase	)

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

															self.check_hidden_states_output(__lowercase      ,				__lowercase      ,				__lowercase      ,				__lowercase	)





							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()
											__a       =		3

											__a       =		(
											    self.model_tester.image_size
											    if isinstance(self.model_tester.image_size      ,				collections.abc.Iterable	)
											    else (self.model_tester.image_size, self.model_tester.image_size)
											)
											__a       =		(
											    config.patch_size
											    if isinstance(config.patch_size      ,				collections.abc.Iterable	)
											    else (config.patch_size, config.patch_size)
											)

											__a       =		image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
											__a       =		image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

											for model_class in self.all_model_classes:
															__a       =		True
															self.check_hidden_states_output(__lowercase      ,				__lowercase      ,				__lowercase      ,				(padded_height, padded_width)	)

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															__a       =		True
															self.check_hidden_states_output(__lowercase      ,				__lowercase      ,				__lowercase      ,				(padded_height, padded_width)	)





							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*__lowercase	)





							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*__lowercase	)





							@slow
							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															__a       =		SwinvaModel.from_pretrained(__lowercase	)
															self.assertIsNotNone(__lowercase	)







							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a     ,					__a       =		self.model_tester.prepare_config_and_inputs_for_common()

											__a       =		_config_zero_init(__lowercase	)
											for model_class in self.all_model_classes:
															__a       =		model_class(config=__lowercase	)
															for name, param in model.named_parameters():
																			if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
																							self.assertIn(
																							    ((param.data.mean() * 1E9).round() / 1E9).item()      ,				[0.0, 1.0]      ,				msg=F"Parameter {name} of model {model_class} seems not properly initialized"      ,				)






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





							@cached_property
							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											return (
											    AutoImageProcessor.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""	)
											    if is_vision_available()
											    else None
											)







							@slow
							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a       =		SwinvaForImageClassification.from_pretrained("""microsoft/swinv2-tiny-patch4-window8-256"""	).to(
											    __lowercase	)
											__a       =		self.default_image_processor

											__a       =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
											__a       =		image_processor(images=__lowercase      ,				return_tensors="""pt"""	).to(__lowercase	)

											# forward pass
											with torch.no_grad():
															__a       =		model(**__lowercase	)

											# verify the logits
											__a       =		torch.Size((1, 1000)	)
											self.assertEqual(outputs.logits.shape      ,				__lowercase	)
											__a       =		torch.tensor([-0.3947, -0.4306, 0.0026]	).to(__lowercase	)
											self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,				__lowercase      ,				atol=1E-4	)	)





from __future__ import annotations

lowerCamelCase__			= """Muhammad Umer Farooq"""
lowerCamelCase__			= """MIT"""
lowerCamelCase__			= """1.0.0"""
lowerCamelCase__			= """Muhammad Umer Farooq"""
lowerCamelCase__			= """contact@muhammadumerfarooq.me"""
lowerCamelCase__			= """Alpha"""

import re
from html.parser import HTMLParser
from urllib import parse

import requests






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__					):





							def __init__(   self		:		Any      ,				__lowercase		:		str	):

											'''simple docstring'''
											super().__init__()
											__a       =		[]
											__a       =		domain







							def 						UpperCamelCase_					(   self		:		Union[str, Any]      ,				__lowercase		:		str      ,				__lowercase		:		list[tuple[str, str | None]]	):

											'''simple docstring'''
											# Only parse the 'anchor' tag.
											if tag == "a":
															# Check the list of defined attributes.
															for name, value in attrs:
																			# If href is defined, and not empty nor # print it.
																			if name == "href" and value != "#" and value != "":
																							# If not already in urls.
																							if value not in self.urls:
																											__a       =		parse.urljoin(self.domain      ,				__lowercase	)
																											self.urls.append(__lowercase	)



def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str    ):
				"""simple docstring"""







				return ".".join(get_sub_domain_name(_SCREAMING_SNAKE_CASE    ).split("""."""    )[-2:]    )

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str    ):
				"""simple docstring"""







				return parse.urlparse(_SCREAMING_SNAKE_CASE    ).netloc

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str = "https://github.com"    ):
				"""simple docstring"""







				__a       =		get_domain_name(_SCREAMING_SNAKE_CASE    )

				# Initialize the parser
				__a       =		Parser(_SCREAMING_SNAKE_CASE    )

				try:
								# Open URL
								__a       =		requests.get(_SCREAMING_SNAKE_CASE    )

								# pass the raw HTML to the parser to get links
								parser.feed(r.text    )

								# Get links and loop through
								__a       =		set()
								for link in parser.urls:
												# open URL.
												# read = requests.get(link)
												try:
																__a       =		requests.get(_SCREAMING_SNAKE_CASE    )
																# Get the valid email.
																__a       =		re.findall("""[a-zA-Z0-9]+@""" + domain				,     read.text    )
																# If not in list then append it.
																for email in emails:
																				valid_emails.add(_SCREAMING_SNAKE_CASE    )
												except ValueError:
																pass
				except ValueError:
								raise SystemExit(1    )

				# Finally return a sorted list of email addresses with no duplicates.
				return sorted(_SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
						lowerCamelCase__			= emails_from_url("""https://github.com""")
						print(F"""{len(emails)} emails found:""")
						print("""\n""".join(sorted(emails)))
