





import inspect
import unittest

from transformers import ConvNextConfig
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 transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
					from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor


class   A      :
			'''simple docstring'''




			def __init__(      self       :   Tuple							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   List[Any]=13							,     __lowerCAmelCase       :   Union[str, Any]=32							,     __lowerCAmelCase       :   List[Any]=3							,     __lowerCAmelCase       :   Optional[Any]=4							,     __lowerCAmelCase       :   Optional[int]=[10, 20, 30, 40]							,     __lowerCAmelCase       :   int=[2, 2, 3, 2]							,     __lowerCAmelCase       :   Optional[Any]=True							,     __lowerCAmelCase       :   Tuple=True							,     __lowerCAmelCase       :   Tuple=37							,     __lowerCAmelCase       :   Any="gelu"							,     __lowerCAmelCase       :   str=10							,     __lowerCAmelCase       :   str=0.0_2							,     __lowerCAmelCase       :   Tuple=["stage2", "stage3", "stage4"]							,     __lowerCAmelCase       :   Tuple=[2, 3, 4]							,     __lowerCAmelCase       :   Tuple=None							,     )     ->     List[str]:







					"""simple docstring"""






					A__  				=       parent
					A__  				=       batch_size
					A__  				=       image_size
					A__  				=       num_channels
					A__  				=       num_stages
					A__  				=       hidden_sizes
					A__  				=       depths
					A__  				=       is_training
					A__  				=       use_labels
					A__  				=       intermediate_size
					A__  				=       hidden_act
					A__  				=       num_labels
					A__  				=       initializer_range
					A__  				=       out_features
					A__  				=       out_indices
					A__  				=       scope






			def        a_	(      self       :   Any       )     ->     Dict:







					"""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.num_labels       )

					A__  				=       self.get_config()
					return config, pixel_values, labels






			def        a_	(      self       :   int       )     ->     List[Any]:







					"""simple docstring"""






					return ConvNextConfig(
					    num_channels=self.num_channels							,     hidden_sizes=self.hidden_sizes							,     depths=self.depths							,     num_stages=self.num_stages							,     hidden_act=self.hidden_act							,     is_decoder=__lowerCamelCase							,     initializer_range=self.initializer_range							,     out_features=self.out_features							,     out_indices=self.out_indices							,     num_labels=self.num_labels							,     )






			def        a_	(      self       :   Optional[int]							,     __lowerCAmelCase       :   Dict							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   Dict       )     ->     Dict:







					"""simple docstring"""






					A__  				=       ConvNextModel(config=__lowerCamelCase       )
					model.to(__lowerCamelCase       )
					model.eval()
					A__  				=       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       :   Optional[int]							,     __lowerCAmelCase       :   List[Any]							,     __lowerCAmelCase       :   str							,     __lowerCAmelCase       :   Optional[Any]       )     ->     str:







					"""simple docstring"""






					A__  				=       ConvNextForImageClassification(__lowerCamelCase       )
					model.to(__lowerCamelCase       )
					model.eval()
					A__  				=       model(__lowerCamelCase							,     labels=__lowerCamelCase       )
					self.parent.assertEqual(result.logits.shape							,     (self.batch_size, self.num_labels)       )






			def        a_	(      self       :   Tuple							,     __lowerCAmelCase       :   List[str]							,     __lowerCAmelCase       :   Union[str, Any]							,     __lowerCAmelCase       :   Union[str, Any]       )     ->     List[Any]:







					"""simple docstring"""






					A__  				=       ConvNextBackbone(config=__lowerCamelCase       )
					model.to(__lowerCamelCase       )
					model.eval()
					A__  				=       model(__lowerCamelCase       )

					# verify hidden states
					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
					A__  				=       None
					A__  				=       ConvNextBackbone(config=__lowerCamelCase       )
					model.to(__lowerCamelCase       )
					model.eval()
					A__  				=       model(__lowerCamelCase       )

					# 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       :   str       )     ->     List[str]:







					"""simple docstring"""






					A__  				=       self.prepare_config_and_inputs()
					A__  				=       config_and_inputs
					A__  				=       {"""pixel_values""": pixel_values}
					return config, inputs_dict


@require_torch
class   A      (_a       ,					_a       ,					unittest.TestCase   ):
			'''simple docstring'''




			__lowerCamelCase     :	Tuple          =   (
			    (
			        ConvNextModel,
			        ConvNextForImageClassification,
			        ConvNextBackbone,
			    )
			    if is_torch_available()
			    else ()
			)
			__lowerCamelCase     :	str          =   (
			    {"""feature-extraction""": ConvNextModel, """image-classification""": ConvNextForImageClassification}
			    if is_torch_available()
			    else {}
			)

			__lowerCamelCase     :	List[str]          =   True
			__lowerCamelCase     :	Any          =   False
			__lowerCamelCase     :	int          =   False
			__lowerCamelCase     :	Union[str, Any]          =   False
			__lowerCamelCase     :	Dict          =   False






			def        a_	(      self       :   Optional[int]       )     ->     Dict:







					"""simple docstring"""






					A__  				=       ConvNextModelTester(self       )
					A__  				=       ConfigTester(self							,     config_class=__lowerCamelCase							,     has_text_modality=__lowerCamelCase							,     hidden_size=37       )






			def        a_	(      self       :   Optional[int]       )     ->     int:







					"""simple docstring"""






					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       :   Any       )     ->     Dict:







					"""simple docstring"""






					return






			@unittest.skip(reason="""ConvNext does not use inputs_embeds"""       )
			def        a_	(      self       :   Dict       )     ->     Dict:







					"""simple docstring"""






					pass






			@unittest.skip(reason="""ConvNext does not support input and output embeddings"""       )
			def        a_	(      self       :   Optional[int]       )     ->     List[str]:







					"""simple docstring"""






					pass






			@unittest.skip(reason="""ConvNext does not use feedforward chunking"""       )
			def        a_	(      self       :   Tuple       )     ->     Optional[int]:







					"""simple docstring"""






					pass






			def        a_	(      self       :   Union[str, Any]       )     ->     str:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
							A__  				=       model_class(__lowerCamelCase       )
							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]							,     __lowerCamelCase       )






			def        a_	(      self       :   str       )     ->     Tuple:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__lowerCamelCase       )






			def        a_	(      self       :   List[Any]       )     ->     Optional[int]:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*__lowerCamelCase       )






			def        a_	(      self       :   Dict       )     ->     List[str]:







					"""simple docstring"""






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

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

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

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

							# ConvNext'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]							,     )

					A__  				=       self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
							A__  				=       True
							check_hidden_states_output(__lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase       )

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

							check_hidden_states_output(__lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase       )






			def        a_	(      self       :   Any       )     ->     List[Any]:







					"""simple docstring"""






					A__  				=       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase       )







			@slow
			def        a_	(      self       :   Dict       )     ->     Optional[Any]:







					"""simple docstring"""






					for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							A__  				=       ConvNextModel.from_pretrained(__lowerCamelCase       )
							self.assertIsNotNone(__lowerCamelCase       )







def        __lowerCamelCase (							)		->    str:






		"""simple docstring"""

		A__  				=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
		return image


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




			@cached_property
			def        a_	(      self       :   List[Any]       )     ->     Tuple:







					"""simple docstring"""






					return AutoImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""       ) if is_vision_available() else None







			@slow
			def        a_	(      self       :   Optional[int]       )     ->     Optional[int]:







					"""simple docstring"""






					A__  				=       ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""       ).to(__lowerCamelCase       )

					A__  				=       self.default_image_processor
					A__  				=       prepare_img()
					A__  				=       image_processor(images=__lowerCamelCase							,     return_tensors="""pt"""       ).to(__lowerCamelCase       )

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

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

					A__  				=       torch.tensor([-0.0_2_6_0, -0.4_7_3_9, 0.1_9_1_1]       ).to(__lowerCamelCase       )

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


@require_torch
class   A      (unittest.TestCase       ,					_a   ):
			'''simple docstring'''




			__lowerCamelCase     :	List[str]          =   (ConvNextBackbone,) if is_torch_available() else ()
			__lowerCamelCase     :	int          =   ConvNextConfig

			__lowerCamelCase     :	Dict          =   False






			def        a_	(      self       :   Any       )     ->     List[Any]:







					"""simple docstring"""






					A__  				=       ConvNextModelTester(self       )








from maths.is_square_free import is_square_free
from maths.prime_factors import prime_factors







def        __lowerCamelCase (							__a       :int   )		->    int:






		"""simple docstring"""

		A__  				=       prime_factors(__a   )
		if is_square_free(__a   ):
				return -1 if len(__a   ) % 2 else 1
		return 0


if __name__ == "__main__":
					import doctest

					doctest.testmod()



