
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 				UpperCAmelCase :




	'''simple docstring'''





	def __init__(			self   :					str				,A   :					Union[str, Any]				,A   :					List[Any]=None				,A   :					str=None				,A   :					Optional[int]=None				,A   :					Optional[Any]="resnet50"				,A   :					List[str]=3				,A   :					Dict=32				,A   :					Union[str, Any]=3				,A   :					List[str]=True				,A   :					Optional[Any]=True				,):
					__A       =					parent
					__A       =					out_indices if out_indices is not None else [4]
					__A       =					stage_names
					__A       =					out_features
					__A       =					backbone
					__A       =					batch_size
					__A       =					image_size
					__A       =					num_channels
					__A       =					use_pretrained_backbone
					__A       =					is_training






	def 							UpperCamelCase_    (			self   :					Optional[Any]					):
					__A       =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)
					__A       =					self.get_config()

					return config, pixel_values






	def 							UpperCamelCase_    (			self   :					Optional[Any]					):
					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 							UpperCamelCase_    (			self   :					Optional[Any]				,A   :					List[str]				,A   :					Tuple					):
					__A       =					TimmBackbone(config=A					)
					model.to(A					)
					model.eval()
					with torch.no_grad():
									__A       =					model(A					)
					self.parent.assertEqual(
					    result.feature_map[-1].shape				,(self.batch_size, model.channels[-1], 14, 14)				,)







	def 							UpperCamelCase_    (			self   :					Tuple					):
					__A       =					self.prepare_config_and_inputs()
					__A       =					config_and_inputs
					__A       =					{'pixel_values': pixel_values}
					return config, inputs_dict





@require_torch
@require_timm
class 				UpperCAmelCase (    _a     ,     _a     ,     _a     ,     unittest.TestCase    ):




	'''simple docstring'''





	snake_case_          =	(TimmBackbone,) if is_torch_available() else ()
	snake_case_          =	{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
	snake_case_          =	False
	snake_case_          =	False
	snake_case_          =	False
	snake_case_          =	False






	def 							UpperCamelCase_    (			self   :					Dict					):
					__A       =					TimmBackboneModelTester(self					)
					__A       =					ConfigTester(self				,config_class=A				,has_text_modality=A					)






	def 							UpperCamelCase_    (			self   :					List[str]					):
					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   :					Dict					):
					__A       =					'resnet18'
					__A       =					'microsoft/resnet-18'

					__A       =					AutoBackbone.from_pretrained(A				,use_timm_backbone=A					)
					__A       =					AutoBackbone.from_pretrained(A					)

					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]					)

					__A       =					AutoBackbone.from_pretrained(A				,use_timm_backbone=A				,out_indices=[1, 2, 3]					)
					__A       =					AutoBackbone.from_pretrained(A				,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 							UpperCamelCase_    (			self   :					str					):
					pass






	@unittest.skip("TimmBackbone doesn\'t have num_hidden_layers attribute"					)
	def 							UpperCamelCase_    (			self   :					Dict					):
					pass






	@unittest.skip("TimmBackbone initialization is managed on the timm side"					)
	def 							UpperCamelCase_    (			self   :					Union[str, Any]					):
					pass






	@unittest.skip("TimmBackbone models doesn\'t have inputs_embeds"					)
	def 							UpperCamelCase_    (			self   :					str					):
					pass






	@unittest.skip("TimmBackbone models doesn\'t have inputs_embeds"					)
	def 							UpperCamelCase_    (			self   :					int					):
					pass






	@unittest.skip("TimmBackbone model cannot be created without specifying a backbone checkpoint"					)
	def 							UpperCamelCase_    (			self   :					int					):
					pass






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






	@unittest.skip("model weights aren\'t tied in TimmBackbone."					)
	def 							UpperCamelCase_    (			self   :					str					):
					pass






	@unittest.skip("model weights aren\'t tied in TimmBackbone."					)
	def 							UpperCamelCase_    (			self   :					int					):
					pass






	@unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone"					)
	def 							UpperCamelCase_    (			self   :					Any					):
					pass






	@unittest.skip("Only checkpoints on timm can be loaded into TimmBackbone"					)
	def 							UpperCamelCase_    (			self   :					Any					):
					pass






	@unittest.skip("TimmBackbone doesn\'t have hidden size info in its configuration."					)
	def 							UpperCamelCase_    (			self   :					Optional[int]					):
					pass






	@unittest.skip("TimmBackbone doesn\'t support output_attentions."					)
	def 							UpperCamelCase_    (			self   :					Optional[int]					):
					pass






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






	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."					)
	def 							UpperCamelCase_    (			self   :					Tuple					):
					pass






	def 							UpperCamelCase_    (			self   :					Dict					):
					__A       =					self.model_tester.prepare_config_and_inputs_for_common()

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






	def 							UpperCamelCase_    (			self   :					Optional[int]					):
					__A       =					self.model_tester.prepare_config_and_inputs_for_common()
					__A       =					True
					__A       =					self.has_attentions

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

					__A       =					self._prepare_for_class(A				,A					)
					__A       =					model(**A					)
					__A       =					outputs[0][-1]

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

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

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

					self.assertIsNotNone(hidden_states.grad					)

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







	def 							UpperCamelCase_    (			self   :					Optional[int]					):
					__A       =					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									__A       =					model_class(A					)
									model.to(A					)
									model.eval()
									__A       =					model(**A					)

									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
									__A       =					copy.deepcopy(A					)
									__A       =					None
									__A       =					model_class(A					)
									model.to(A					)
									model.eval()
									__A       =					model(**A					)

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

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




from argparse import ArgumentParser

from .add_new_model import AddNewModelCommand
from .add_new_model_like import AddNewModelLikeCommand
from .convert import ConvertCommand
from .download import DownloadCommand
from .env import EnvironmentCommand
from .lfs import LfsCommands
from .pt_to_tf import PTtoTFCommand
from .run import RunCommand
from .serving import ServeCommand
from .user import UserCommands



def 							UpperCamelCase_( )       ->		List[Any]:
    _lowercase			:				int 						=						ArgumentParser('Transformers CLI tool'				,					usage='transformers-cli <command> [<args>]'					)
    _lowercase			:				Optional[Any] 						=						parser.add_subparsers(help='transformers-cli command helpers'					)

    # Register commands
    ConvertCommand.register_subcommand(lowerCamelCase_					)
    DownloadCommand.register_subcommand(lowerCamelCase_					)
    EnvironmentCommand.register_subcommand(lowerCamelCase_					)
    RunCommand.register_subcommand(lowerCamelCase_					)
    ServeCommand.register_subcommand(lowerCamelCase_					)
    UserCommands.register_subcommand(lowerCamelCase_					)
    AddNewModelCommand.register_subcommand(lowerCamelCase_					)
    AddNewModelLikeCommand.register_subcommand(lowerCamelCase_					)
    LfsCommands.register_subcommand(lowerCamelCase_					)
    PTtoTFCommand.register_subcommand(lowerCamelCase_					)

    # Let's go
    _lowercase			:				Any 						=						parser.parse_args()

    if not hasattr(lowerCamelCase_				,					'func'					):
        parser.print_help()
        exit(1					)

    # Run
    _lowercase			:				Optional[int] 						=						args.func(lowerCamelCase_					)
    service.run()


if __name__ == "__main__":
 main()


