




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



 '''simple docstring'''


 def __init__(							self   :    Tuple		,				A_   :    Optional[int]		,				A_   :    Optional[Any]=None		,				A_   :    Dict=None		,				A_   :    List[str]=None		,				A_   :    int="resnet50"		,				A_   :    Dict=3		,				A_   :    Union[str, Any]=32		,				A_   :    Union[str, Any]=3		,				A_   :    Dict=True		,				A_   :    List[str]=True		,				)  ->      Tuple:

       """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   :    Tuple    )  ->      str:

       """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]    )  ->      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   :    Dict		,				A_   :    List[Any]		,				A_   :    List[Any]    )  ->      Optional[Any]:

       """simple docstring"""






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





 def 							a__					(							self   :    str    )  ->      Optional[int]:

       """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     A(		__lowercase				, __lowercase				, __lowercase				, unittest.TestCase  ):



 '''simple docstring'''


 UpperCamelCase		  =		(TimmBackbone,) if is_torch_available() else ()
 UpperCamelCase		  =		{'''feature-extraction''': TimmBackbone} if is_torch_available() else {}
 UpperCamelCase		  =		False
 UpperCamelCase		  =		False
 UpperCamelCase		  =		False
 UpperCamelCase		  =		False

 def 							a__					(							self   :    Dict    )  ->      Any:

       """simple docstring"""






       lowerCamelCase_							=       TimmBackboneModelTester(self    )
       lowerCamelCase_							=       ConfigTester(self		,				config_class=A_		,				has_text_modality=A_    )

 def 							a__					(							self   :    str    )  ->      str:

       """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   :    Optional[int]    )  ->      Dict:

       """simple docstring"""






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

       lowerCamelCase_							=       AutoBackbone.from_pretrained(A_		,				use_timm_backbone=A_    )
       lowerCamelCase_							=       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]    )

       lowerCamelCase_							=       AutoBackbone.from_pretrained(A_		,				use_timm_backbone=A_		,				out_indices=[1, 2, 3]    )
       lowerCamelCase_							=       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 							a__					(							self   :    Dict    )  ->      Dict:

       """simple docstring"""






       pass

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

       """simple docstring"""






       pass

 @unittest.skip('TimmBackbone initialization is managed on the timm side'    )
 def 							a__					(							self   :    Any    )  ->      Optional[int]:

       """simple docstring"""






       pass

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

       """simple docstring"""






       pass

 @unittest.skip('TimmBackbone models doesn\'t have inputs_embeds'    )
 def 							a__					(							self   :    Dict    )  ->      int:

       """simple docstring"""






       pass

 @unittest.skip('TimmBackbone model cannot be created without specifying a backbone checkpoint'    )
 def 							a__					(							self   :    Dict    )  ->      Optional[Any]:

       """simple docstring"""






       pass

 @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'    )
 def 							a__					(							self   :    Tuple    )  ->      List[str]:

       """simple docstring"""






       pass

 @unittest.skip('model weights aren\'t tied in TimmBackbone.'    )
 def 							a__					(							self   :    str    )  ->      Any:

       """simple docstring"""






       pass

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

       """simple docstring"""






       pass

 @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'    )
 def 							a__					(							self   :    Dict    )  ->      List[Any]:

       """simple docstring"""






       pass

 @unittest.skip('Only checkpoints on timm can be loaded into TimmBackbone'    )
 def 							a__					(							self   :    Any    )  ->      List[str]:

       """simple docstring"""






       pass

 @unittest.skip('TimmBackbone doesn\'t have hidden size info in its configuration.'    )
 def 							a__					(							self   :    Optional[Any]    )  ->      Tuple:

       """simple docstring"""






       pass

 @unittest.skip('TimmBackbone doesn\'t support output_attentions.'    )
 def 							a__					(							self   :    List[str]    )  ->      List[Any]:

       """simple docstring"""






       pass

 @unittest.skip('Safetensors is not supported by timm.'    )
 def 							a__					(							self   :    Optional[Any]    )  ->      Tuple:

       """simple docstring"""






       pass

 @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'    )
 def 							a__					(							self   :    int    )  ->      Dict:

       """simple docstring"""






       pass

 def 							a__					(							self   :    Optional[Any]    )  ->      Dict:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs_for_common()

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

 def 							a__					(							self   :    Optional[int]    )  ->      Union[str, 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(A_    )
       model.to(A_    )

       lowerCamelCase_							=       self._prepare_for_class(A_		,				A_    )
       lowerCamelCase_							=       model(**A_    )
       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=A_    )

       self.assertIsNotNone(hidden_states.grad    )

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





 def 							a__					(							self   :    List[str]    )  ->      Optional[int]:

       """simple docstring"""






       lowerCamelCase_							=       self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             lowerCamelCase_							=       model_class(A_    )
             model.to(A_    )
             model.eval()
             lowerCamelCase_							=       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
             lowerCamelCase_							=       copy.deepcopy(A_    )
             lowerCamelCase_							=       None
             lowerCamelCase_							=       model_class(A_    )
             model.to(A_    )
             model.eval()
             lowerCamelCase_							=       model(**A_    )

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

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










'''simple docstring'''






import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


__UpperCamelCase					    =	logging.getLogger()




@unittest.skip('''Temporarily disable the doc tests.'''		)
@require_torch
@require_tf
@slow
class  _A (					unittest.TestCase		):

		def 	lowercase__     (   self					:   Optional[int]  ,      __magic_name__					:   Path  ,      __magic_name__					:   Union[str, None] = None  ,      __magic_name__					:   Union[List[str], None] = None  ,      __magic_name__					:   Union[str, List[str], None] = None  ,      __magic_name__					:   bool = True  ,      )					->    Optional[int]:


					"""simple docstring"""

					__snake_case					:      Union[str, Any]							      =     [file for file in os.listdir(__magic_name__			) if os.path.isfile(os.path.join(__magic_name__  ,      __magic_name__			)			)]

					if identifier is not None:
								__snake_case					:      List[Any]							      =     [file for file in files if identifier in file]

					if n_identifier is not None:
								if isinstance(__magic_name__  ,      __magic_name__			):
											for n_ in n_identifier:
														__snake_case					:      Optional[int]							      =     [file for file in files if n_ not in file]
								else:
											__snake_case					:      Tuple							      =     [file for file in files if n_identifier not in file]

					__snake_case					:      Dict							      =     ignore_files or []
					ignore_files.append("""__init__.py"""			)
					__snake_case					:      List[str]							      =     [file for file in files if file not in ignore_files]

					for file in files:
								# Open all files
								print("""Testing"""  ,      __magic_name__			)

								if only_modules:
											__snake_case					:      List[Any]							      =     file.split("""."""			)[0]
											try:
														__snake_case					:      List[Any]							      =     getattr(__magic_name__  ,      __magic_name__			)
														__snake_case					:      Union[str, Any]							      =     doctest.DocTestSuite(__magic_name__			)
														__snake_case					:      Dict							      =     unittest.TextTestRunner().run(__magic_name__			)
														self.assertIs(len(result.failures			)  ,      0			)
											except AttributeError:
														logger.info(f'''{module_identifier} is not a module.'''			)
								else:
											__snake_case					:      Tuple							      =     doctest.testfile(str("""..""" / directory / file			)  ,      optionflags=doctest.ELLIPSIS			)
											self.assertIs(result.failed  ,      0			)

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


					"""simple docstring"""

					__snake_case					:      List[Any]							      =     Path("""src/transformers"""			)
					__snake_case					:      List[Any]							      =     """modeling"""
					__snake_case					:      Union[str, Any]							      =     [
					    """modeling_ctrl.py""",
					    """modeling_tf_ctrl.py""",
					]
					self.analyze_directory(__magic_name__  ,      identifier=__magic_name__  ,      ignore_files=__magic_name__			)

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


					"""simple docstring"""

					__snake_case					:      Union[str, Any]							      =     Path("""src/transformers"""			)
					__snake_case					:      Any							      =     """tokenization"""
					self.analyze_directory(__magic_name__  ,      identifier=__magic_name__			)

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


					"""simple docstring"""

					__snake_case					:      List[Any]							      =     Path("""src/transformers"""			)
					__snake_case					:      List[str]							      =     """configuration"""
					self.analyze_directory(__magic_name__  ,      identifier=__magic_name__			)

		def 	lowercase__     (   self					:   Dict			)					->    Dict:


					"""simple docstring"""

					__snake_case					:      Tuple							      =     Path("""src/transformers"""			)
					__snake_case					:      int							      =     ["""configuration""", """modeling""", """tokenization"""]
					self.analyze_directory(__magic_name__  ,      n_identifier=__magic_name__			)

		def 	lowercase__     (   self					:   Optional[int]			)					->    Union[str, Any]:


					"""simple docstring"""

					__snake_case					:      int							      =     Path("""docs/source"""			)
					__snake_case					:      Optional[int]							      =     ["""favicon.ico"""]
					self.analyze_directory(__magic_name__  ,      ignore_files=__magic_name__  ,      only_modules=__magic_name__			)


