





"""simple docstring"""




import collections
import inspect
import unittest

from transformers import FocalNetConfig
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, _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 (
		    FocalNetBackbone,
		    FocalNetForImageClassification,
		    FocalNetForMaskedImageModeling,
		    FocalNetModel,
		)
		from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor


class        __UpperCamelCase				:






							def __init__(   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__=13      ,					lowerCAmelCase__=32      ,					lowerCAmelCase__=2      ,					lowerCAmelCase__=3      ,					lowerCAmelCase__=16      ,					lowerCAmelCase__=[32, 64, 128]      ,					lowerCAmelCase__=[1, 2, 1]      ,					lowerCAmelCase__=[2, 2, 4]      ,					lowerCAmelCase__=2      ,					lowerCAmelCase__=2.0      ,					lowerCAmelCase__=True      ,					lowerCAmelCase__=0.0      ,					lowerCAmelCase__=0.0      ,					lowerCAmelCase__=0.1      ,					lowerCAmelCase__="gelu"      ,					lowerCAmelCase__=False      ,					lowerCAmelCase__=True      ,					lowerCAmelCase__=0.02      ,					lowerCAmelCase__=1E-5      ,					lowerCAmelCase__=True      ,					lowerCAmelCase__=None      ,					lowerCAmelCase__=True      ,					lowerCAmelCase__=10      ,					lowerCAmelCase__=8      ,					lowerCAmelCase__=["stage1", "stage2"]      ,					lowerCAmelCase__=[1, 2]      ,					)	-> Union[str, Any]:
								a      :		List[Any]	=				parent
								a      :		Tuple	=				batch_size
								a      :		List[Any]	=				image_size
								a      :		Dict	=				patch_size
								a      :		List[str]	=				num_channels
								a      :		List[str]	=				embed_dim
								a      :		Optional[int]	=				hidden_sizes
								a      :		int	=				depths
								a      :		str	=				num_heads
								a      :		str	=				window_size
								a      :		List[Any]	=				mlp_ratio
								a      :		int	=				qkv_bias
								a      :		Dict	=				hidden_dropout_prob
								a      :		Dict	=				attention_probs_dropout_prob
								a      :		List[str]	=				drop_path_rate
								a      :		Tuple	=				hidden_act
								a      :		Optional[Any]	=				use_absolute_embeddings
								a      :		List[str]	=				patch_norm
								a      :		str	=				layer_norm_eps
								a      :		List[Any]	=				initializer_range
								a      :		Tuple	=				is_training
								a      :		List[Any]	=				scope
								a      :		List[str]	=				use_labels
								a      :		int	=				type_sequence_label_size
								a      :		Union[str, Any]	=				encoder_stride
								a      :		int	=				out_features
								a      :		Tuple	=				out_indices






							def     __a   (   self      )	-> Optional[Any]:
								a      :		Optional[int]	=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

								a      :		Tuple	=				None
								if self.use_labels:
									a      :		Dict	=				ids_tensor([self.batch_size]      ,					self.type_sequence_label_size      )

								a      :		int	=				self.get_config()

								return config, pixel_values, labels






							def     __a   (   self      )	-> Tuple:
								return FocalNetConfig(
								    image_size=self.image_size      ,					patch_size=self.patch_size      ,					num_channels=self.num_channels      ,					embed_dim=self.embed_dim      ,					hidden_sizes=self.hidden_sizes      ,					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      ,					out_features=self.out_features      ,					out_indices=self.out_indices      ,					)






							def     __a   (   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )	-> Union[str, Any]:
								a      :		int	=				FocalNetModel(config=__lowercase      )
								model.to(__lowercase      )
								model.eval()
								a      :		Union[str, Any]	=				model(__lowercase      )

								a      :		Union[str, Any]	=				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths      ) - 1))
								a      :		str	=				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     __a   (   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )	-> Dict:
								a      :		Tuple	=				FocalNetBackbone(config=__lowercase      )
								model.to(__lowercase      )
								model.eval()
								a      :		Optional[int]	=				model(__lowercase      )

								# 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.image_size, 8, 8]      )

								# 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
								a      :		int	=				None
								a      :		Dict	=				FocalNetBackbone(config=__lowercase      )
								model.to(__lowercase      )
								model.eval()
								a      :		List[Any]	=				model(__lowercase      )

								# verify feature maps
								self.parent.assertEqual(len(result.feature_maps      )      ,					1      )
								self.parent.assertListEqual(list(result.feature_maps[0].shape      )      ,					[self.batch_size, self.image_size * 2, 4, 4]      )

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






							def     __a   (   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )	-> Tuple:
								a      :		int	=				FocalNetForMaskedImageModeling(config=__lowercase      )
								model.to(__lowercase      )
								model.eval()
								a      :		List[str]	=				model(__lowercase      )
								self.parent.assertEqual(
								    result.reconstruction.shape      ,					(self.batch_size, self.num_channels, self.image_size, self.image_size)      )

								# test greyscale images
								a      :		Union[str, Any]	=				1
								a      :		str	=				FocalNetForMaskedImageModeling(__lowercase      )
								model.to(__lowercase      )
								model.eval()

								a      :		Optional[Any]	=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
								a      :		Dict	=				model(__lowercase      )
								self.parent.assertEqual(result.reconstruction.shape      ,					(self.batch_size, 1, self.image_size, self.image_size)      )






							def     __a   (   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )	-> List[Any]:
								a      :		Union[str, Any]	=				self.type_sequence_label_size
								a      :		Optional[Any]	=				FocalNetForImageClassification(__lowercase      )
								model.to(__lowercase      )
								model.eval()
								a      :		Any	=				model(__lowercase      ,					labels=__lowercase      )
								self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.type_sequence_label_size)      )

								# test greyscale images
								a      :		int	=				1
								a      :		List[str]	=				FocalNetForImageClassification(__lowercase      )
								model.to(__lowercase      )
								model.eval()

								a      :		Optional[int]	=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
								a      :		Optional[int]	=				model(__lowercase      )
								self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.type_sequence_label_size)      )






							def     __a   (   self      )	-> Dict:
								a      :		List[str]	=				self.prepare_config_and_inputs()

								a      :		Tuple	=				config_and_inputs
								a      :		int	=				{'''pixel_values''': pixel_values}
								return config, inputs_dict


@require_torch
class        __UpperCamelCase				(						UpperCAmelCase__		,       UpperCAmelCase__		,       unittest.TestCase						):
							lowerCamelCase   :					List[str]      					=(
							    (
							        FocalNetModel,
							        FocalNetForImageClassification,
							        FocalNetForMaskedImageModeling,
							        FocalNetBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							lowerCamelCase   :					Any      					=(
							    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
							    if is_torch_available()
							    else {}
							)
							lowerCamelCase   :					Union[str, Any]      					=False

							lowerCamelCase   :					Tuple      					=False
							lowerCamelCase   :					Optional[Any]      					=False
							lowerCamelCase   :					Tuple      					=False
							lowerCamelCase   :					str      					=False






							def     __a   (   self      )	-> Tuple:
								a      :		Tuple	=				FocalNetModelTester(self      )
								a      :		int	=				ConfigTester(self      ,					config_class=__lowercase      ,					embed_dim=37      ,					has_text_modality=__lowercase      )






							def     __a   (   self      )	-> Dict:
								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      )	-> Union[str, Any]:
								return






							def     __a   (   self      )	-> str:
								a      :		List[Any]	=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__lowercase      )






							def     __a   (   self      )	-> Dict:
								a      :		Union[str, Any]	=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*__lowercase      )






							def     __a   (   self      )	-> Union[str, Any]:
								a      :		str	=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*__lowercase      )






							def     __a   (   self      )	-> Tuple:
								a      :		List[str]	=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*__lowercase      )






							@unittest.skip(reason="FocalNet does not use inputs_embeds"      )
							def     __a   (   self      )	-> List[Any]:
								pass






							@unittest.skip(reason="FocalNet does not use feedforward chunking"      )
							def     __a   (   self      )	-> Dict:
								pass






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

								for model_class in self.all_model_classes[:-1]:
									a      :		Optional[Any]	=				model_class(__lowercase      )
									self.assertIsInstance(model.get_input_embeddings()      ,					(nn.Module)      )
									a      :		Union[str, Any]	=				model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(__lowercase      ,					nn.Linear      )      )






							def     __a   (   self      )	-> int:
								a      :		List[Any]	=				self.model_tester.prepare_config_and_inputs_for_common()

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

									a      :		Optional[int]	=				['''pixel_values''']
									self.assertListEqual(arg_names[:1]      ,					__lowercase      )






							def     __a   (   self      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      ,					lowerCAmelCase__      )	-> Dict:
								a      :		Tuple	=				model_class(__lowercase      )
								model.to(__lowercase      )
								model.eval()

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

								a      :		Union[str, Any]	=				outputs.hidden_states

								a      :		List[str]	=				getattr(
								    self.model_tester      ,					"expected_num_hidden_layers"      ,					len(self.model_tester.depths      ) + 1      )
								self.assertEqual(len(__lowercase      )      ,					__lowercase      )

								# FocalNet has a different seq_length
								a      :		Dict	=				(
								    config.patch_size
								    if isinstance(config.patch_size      ,					collections.abc.Iterable      )
								    else (config.patch_size, config.patch_size)
								)

								a      :		List[str]	=				(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      :		Any	=				outputs.reshaped_hidden_states
								self.assertEqual(len(__lowercase      )      ,					__lowercase      )

								a      :		List[str]	=				reshaped_hidden_states[0].shape
								a      :		Tuple	=				(
								    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     __a   (   self      )	-> Union[str, Any]:
								a      :		Any	=				self.model_tester.prepare_config_and_inputs_for_common()

								a      :		List[Any]	=				(
								    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[:-1]:
									a      :		Optional[int]	=				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      :		Dict	=				True

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






							def     __a   (   self      )	-> Dict:
								a      :		Union[str, Any]	=				self.model_tester.prepare_config_and_inputs_for_common()
								a      :		Optional[int]	=				3

								a      :		int	=				(
								    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      :		Any	=				(
								    config.patch_size
								    if isinstance(config.patch_size      ,					collections.abc.Iterable      )
								    else (config.patch_size, config.patch_size)
								)

								a      :		Optional[int]	=				image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
								a      :		str	=				image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

								for model_class in self.all_model_classes[:-1]:
									a      :		Union[str, Any]	=				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      :		Union[str, Any]	=				True
									self.check_hidden_states_output(__lowercase      ,					__lowercase      ,					__lowercase      ,					(padded_height, padded_width)      )






							@slow
							def     __a   (   self      )	-> List[str]:
								for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									a      :		List[Any]	=				FocalNetModel.from_pretrained(__lowercase      )
									self.assertIsNotNone(__lowercase      )






							def     __a   (   self      )	-> Dict:
								a      :		str	=				self.model_tester.prepare_config_and_inputs_for_common()

								a      :		int	=				_config_zero_init(__lowercase      )
								for model_class in self.all_model_classes:
									a      :		Tuple	=				model_class(config=__lowercase      )
									for name, param in model.named_parameters():
										if "embeddings" 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        __UpperCamelCase				(						unittest.TestCase						):






							@cached_property
							def     __a   (   self      )	-> List[Any]:
								# TODO update organization
								return AutoImageProcessor.from_pretrained("microsoft/focalnet-tiny"      ) if is_vision_available() else None






							@slow
							def     __a   (   self      )	-> Any:
								a      :		List[Any]	=				FocalNetForImageClassification.from_pretrained("microsoft/focalnet-tiny"      ).to(__lowercase      )
								a      :		List[Any]	=				self.default_image_processor

								a      :		Optional[Any]	=				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
								a      :		Dict	=				image_processor(images=__lowercase      ,					return_tensors="pt"      ).to(__lowercase      )

								# forward pass
								with torch.no_grad():
									a      :		List[str]	=				model(**__lowercase      )

								# verify the logits
								a      :		List[Any]	=				torch.Size((1, 1000)      )
								self.assertEqual(outputs.logits.shape      ,					__lowercase      )
								a      :		Union[str, Any]	=				torch.tensor([0.2_166, -0.4_368, 0.2_191]      ).to(__lowercase      )
								self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,					__lowercase      ,					atol=1E-4      )      )
								self.assertTrue(outputs.logits.argmax(dim=-1      ).item()      ,					281      )


@require_torch
class        __UpperCamelCase				(						UpperCAmelCase__		,       unittest.TestCase						):
							lowerCamelCase   :					Tuple      					=(FocalNetBackbone,) if is_torch_available() else ()
							lowerCamelCase   :					Union[str, Any]      					=FocalNetConfig

							lowerCamelCase   :					List[Any]      					=False






							def     __a   (   self      )	-> Optional[Any]:
								a      :		List[Any]	=				FocalNetModelTester(self      )






from __future__ import annotations

import requests



def 	lowerCAmelCase       (						lowerCAmelCase_       )->       dict:
				lowerCAmelCase_       :					List[Any]			 = f"""https://hacker-news.firebaseio.com/v0/item/{story_id}.json?print=pretty"""
				return requests.get(lowerCAmelCase_       ).json()



def 	lowerCAmelCase       (						lowerCAmelCase_ = 10       )->       list[dict]:
				lowerCAmelCase_       :					List[Any]			 = '''https://hacker-news.firebaseio.com/v0/topstories.json?print=pretty'''
				lowerCAmelCase_       :					Tuple			 = requests.get(lowerCAmelCase_       ).json()[:max_stories]
				return [get_hackernews_story(lowerCAmelCase_       ) for story_id in story_ids]



def 	lowerCAmelCase       (						lowerCAmelCase_ = 10       )->       str:
				lowerCAmelCase_       :					Optional[Any]			 = hackernews_top_stories(lowerCAmelCase_       )
				return "\n".join('''* [{title}]({url})'''.format(**lowerCAmelCase_       ) for story in stories       )


if __name__ == "__main__":
						print(hackernews_top_stories_as_markdown())