


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
		import torch

		from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin







class     __lowercase    :



		"""simple docstring"""

		def __init__(      self						,	A						,	A=None						,	A=None						,	A=None						,	A="resnet50"						,	A=3						,	A=32						,	A=3						,	A=True						,	A=True						,	)   ->      Any:







					'''simple docstring'''







					lowerCamelCase  						=   parent
					lowerCamelCase  						=   out_indices if out_indices is not None else [4]
					lowerCamelCase  						=   stage_names
					lowerCamelCase  						=   out_features
					lowerCamelCase  						=   backbone
					lowerCamelCase  						=   batch_size
					lowerCamelCase  						=   image_size
					lowerCamelCase  						=   num_channels
					lowerCamelCase  						=   use_pretrained_backbone
					lowerCamelCase  						=   is_training







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







					'''simple docstring'''







					lowerCamelCase  						=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )
					lowerCamelCase  						=   self.get_config()

					return config, pixel_values







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







					'''simple docstring'''







					return TimmBackboneConfig(
					    image_size=self.image_size						,	num_channels=self.num_channels						,	out_features=self.out_features						,	out_indices=self.out_indices						,	stage_names=self.stage_names						,	use_pretrained_backbone=self.use_pretrained_backbone						,	backbone=self.backbone						,	)







		def  __A					(      self						,	A						,	A     )   ->      Dict:







					'''simple docstring'''







					lowerCamelCase  						=   TimmBackbone(config=__snake_case     )
					model.to(__snake_case     )
					model.eval()
					with torch.no_grad():
								lowerCamelCase  						=   model(__snake_case     )
					self.parent.assertEqual(
					    result.feature_map[-1].shape						,	(self.batch_size, model.channels[-1], 14, 14)						,	)







		def  __A					(      self     )   ->      Dict:







					'''simple docstring'''







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







@require_torch
@require_timm
class     __lowercase    (				_snake_case       ,				_snake_case       ,				_snake_case       ,				unittest.TestCase   ):



		"""simple docstring"""

		UpperCamelCase			: Optional[Any]           =						(TimmBackbone,) if is_torch_available() else ()
		UpperCamelCase			: Tuple           =						{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
		UpperCamelCase			: Optional[Any]           =						False
		UpperCamelCase			: List[Any]           =						False
		UpperCamelCase			: Dict           =						False
		UpperCamelCase			: int           =						False







		def  __A					(      self     )   ->      Any:







					'''simple docstring'''







					lowerCamelCase  						=   TimmBackboneModelTester(self     )
					lowerCamelCase  						=   ConfigTester(self						,	config_class=__snake_case						,	has_text_modality=__snake_case     )







		def  __A					(      self     )   ->      Tuple:







					'''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  __A					(      self     )   ->      Tuple:







					'''simple docstring'''







					lowerCamelCase  						=   """resnet18"""
					lowerCamelCase  						=   """microsoft/resnet-18"""

					lowerCamelCase  						=   AutoBackbone.from_pretrained(__snake_case						,	use_timm_backbone=__snake_case     )
					lowerCamelCase  						=   AutoBackbone.from_pretrained(__snake_case     )

					self.assertEqual(len(timm_model.out_features     )						,	len(transformers_model.out_features     )     )
					self.assertEqual(len(timm_model.stage_names     )						,	len(transformers_model.stage_names     )     )
					self.assertEqual(timm_model.channels						,	transformers_model.channels     )
					# Out indices are set to the last layer by default. For timm models, we don't know
					# the number of layers in advance, so we set it to (-1,), whereas for transformers
					# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
					self.assertEqual(timm_model.out_indices						,	(-1,)     )
					self.assertEqual(transformers_model.out_indices						,	[len(timm_model.stage_names     ) - 1]     )

					lowerCamelCase  						=   AutoBackbone.from_pretrained(__snake_case						,	use_timm_backbone=__snake_case						,	out_indices=[1, 2, 3]     )
					lowerCamelCase  						=   AutoBackbone.from_pretrained(__snake_case						,	out_indices=[1, 2, 3]     )

					self.assertEqual(timm_model.out_indices						,	transformers_model.out_indices     )
					self.assertEqual(len(timm_model.out_features     )						,	len(transformers_model.out_features     )     )
					self.assertEqual(timm_model.channels						,	transformers_model.channels     )







		@unittest.skip("""TimmBackbone doesn't support feed forward chunking"""     )
		def  __A					(      self     )   ->      Optional[Any]:







					'''simple docstring'''







					pass







		@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""     )
		def  __A					(      self     )   ->      List[str]:







					'''simple docstring'''







					pass







		@unittest.skip("""TimmBackbone initialization is managed on the timm side"""     )
		def  __A					(      self     )   ->      str:







					'''simple docstring'''







					pass







		@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""     )
		def  __A					(      self     )   ->      List[Any]:







					'''simple docstring'''







					pass







		@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""     )
		def  __A					(      self     )   ->      int:







					'''simple docstring'''







					pass







		@unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""     )
		def  __A					(      self     )   ->      Dict:







					'''simple docstring'''







					pass







		@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""     )
		def  __A					(      self     )   ->      Optional[Any]:







					'''simple docstring'''







					pass







		@unittest.skip("""model weights aren't tied in TimmBackbone."""     )
		def  __A					(      self     )   ->      Union[str, Any]:







					'''simple docstring'''







					pass







		@unittest.skip("""model weights aren't tied in TimmBackbone."""     )
		def  __A					(      self     )   ->      int:







					'''simple docstring'''







					pass







		@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""     )
		def  __A					(      self     )   ->      Union[str, Any]:







					'''simple docstring'''







					pass







		@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""     )
		def  __A					(      self     )   ->      int:







					'''simple docstring'''







					pass







		@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""     )
		def  __A					(      self     )   ->      Any:







					'''simple docstring'''







					pass







		@unittest.skip("""TimmBackbone doesn't support output_attentions."""     )
		def  __A					(      self     )   ->      Union[str, Any]:







					'''simple docstring'''







					pass







		@unittest.skip("""Safetensors is not supported by timm."""     )
		def  __A					(      self     )   ->      Union[str, Any]:







					'''simple docstring'''







					pass







		@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""     )
		def  __A					(      self     )   ->      Union[str, Any]:







					'''simple docstring'''







					pass







		def  __A					(      self     )   ->      str:







					'''simple docstring'''







					lowerCamelCase  						=   self.model_tester.prepare_config_and_inputs_for_common()

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







		def  __A					(      self     )   ->      Optional[Any]:







					'''simple docstring'''







					lowerCamelCase  						=   self.model_tester.prepare_config_and_inputs_for_common()
					lowerCamelCase  						=   True
					lowerCamelCase  						=   self.has_attentions

					# no need to test all models as different heads yield the same functionality
					lowerCamelCase  						=   self.all_model_classes[0]
					lowerCamelCase  						=   model_class(__snake_case     )
					model.to(__snake_case     )

					lowerCamelCase  						=   self._prepare_for_class(__snake_case						,	__snake_case     )
					lowerCamelCase  						=   model(**__snake_case     )
					lowerCamelCase  						=   outputs[0][-1]

					# Encoder-/Decoder-only models
					lowerCamelCase  						=   outputs.hidden_states[0]
					hidden_states.retain_grad()

					if self.has_attentions:
								lowerCamelCase  						=   outputs.attentions[0]
								attentions.retain_grad()

					output.flatten()[0].backward(retain_graph=__snake_case     )

					self.assertIsNotNone(hidden_states.grad     )

					if self.has_attentions:
								self.assertIsNotNone(attentions.grad     )







		def  __A					(      self     )   ->      Dict:







					'''simple docstring'''







					lowerCamelCase  						=   self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
								lowerCamelCase  						=   model_class(__snake_case     )
								model.to(__snake_case     )
								model.eval()
								lowerCamelCase  						=   model(**__snake_case     )

								self.assertEqual(len(result.feature_maps     )						,	len(config.out_indices     )     )
								self.assertEqual(len(model.channels     )						,	len(config.out_indices     )     )

								# Check output of last stage is taken if out_features=None, out_indices=None
								lowerCamelCase  						=   copy.deepcopy(__snake_case     )
								lowerCamelCase  						=   None
								lowerCamelCase  						=   model_class(__snake_case     )
								model.to(__snake_case     )
								model.eval()
								lowerCamelCase  						=   model(**__snake_case     )

								self.assertEqual(len(result.feature_maps     )						,	1     )
								self.assertEqual(len(model.channels     )						,	1     )

								# Check backbone can be initialized with fresh weights
								lowerCamelCase  						=   copy.deepcopy(__snake_case     )
								lowerCamelCase  						=   False
								lowerCamelCase  						=   model_class(__snake_case     )
								model.to(__snake_case     )
								model.eval()
								lowerCamelCase  						=   model(**__snake_case     )





'''simple docstring'''


import os
import sys
from contextlib import contextmanager


# Windows only
if os.name == "nt":
				import ctypes
				import msvcrt  # noqa





				class     lowercase__  (						ctypes.Structure					):





											'''simple docstring'''


											A_							:      Optional[Any]      	=  [("""size""", ctypes.c_int), ("""visible""", ctypes.c_byte)]







def 			snake_case_   (  ):







				"""simple docstring"""





				if os.name == "nt":
								_SCREAMING_SNAKE_CASE :       Tuple     		=      CursorInfo()
								_SCREAMING_SNAKE_CASE :       Tuple     		=      ctypes.windll.kernelaa.GetStdHandle(-11     )
								ctypes.windll.kernelaa.GetConsoleCursorInfo(SCREAMING_SNAKE_CASE__							,      ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
								_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      False
								ctypes.windll.kernelaa.SetConsoleCursorInfo(SCREAMING_SNAKE_CASE__							,      ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
				elif os.name == "posix":
								sys.stdout.write("""\033[?25l"""     )
								sys.stdout.flush()







def 			snake_case_   (  ):







				"""simple docstring"""





				if os.name == "nt":
								_SCREAMING_SNAKE_CASE :       int     		=      CursorInfo()
								_SCREAMING_SNAKE_CASE :       List[str]     		=      ctypes.windll.kernelaa.GetStdHandle(-11     )
								ctypes.windll.kernelaa.GetConsoleCursorInfo(SCREAMING_SNAKE_CASE__							,      ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
								_SCREAMING_SNAKE_CASE :       Tuple     		=      True
								ctypes.windll.kernelaa.SetConsoleCursorInfo(SCREAMING_SNAKE_CASE__							,      ctypes.byref(SCREAMING_SNAKE_CASE__     )     )
				elif os.name == "posix":
								sys.stdout.write("""\033[?25h"""     )
								sys.stdout.flush()







@contextmanager
def 			snake_case_   (  ):







				"""simple docstring"""





				try:
								hide_cursor()
								yield
				finally:
								show_cursor()




