code: 
  import copy
  import inspect
  
  from transformers.testing_utils import require_torch, torch_device
  from transformers.utils.backbone_utils import BackboneType
  
  
  
  
  
  @require_torch
  class 						lowerCamelCase			:
  	UpperCamelCase_     :				Tuple								=  ()
  	UpperCamelCase_     :				Union[str, Any]								=  True
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[Any] )		->			Tuple:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE    	=   self.config_class
  
  				# test default config
  				SCREAMING_SNAKE_CASE    	=   config_class()
  				self.assertIsNotNone(lowercase )
  				SCREAMING_SNAKE_CASE    	=   ['''stem'''] + [f"""stage{idx}""" for idx in range(1      ,    len(config.depths ) + 1 )]
  				self.assertEqual(config.stage_names      ,    lowercase )
  				self.assertTrue(set(config.out_features ).issubset(set(config.stage_names ) ) )
  
  				# Test out_features and out_indices are correctly set
  				# out_features and out_indices both None
  				SCREAMING_SNAKE_CASE    	=   config_class(out_features=lowercase      ,    out_indices=lowercase )
  				self.assertEqual(config.out_features      ,    [config.stage_names[-1]] )
  				self.assertEqual(config.out_indices      ,    [len(config.stage_names ) - 1] )
  
  				# out_features and out_indices both set
  				SCREAMING_SNAKE_CASE    	=   config_class(out_features=['''stem''', '''stage1''']      ,    out_indices=[0, 1] )
  				self.assertEqual(config.out_features      ,    ['''stem''', '''stage1'''] )
  				self.assertEqual(config.out_indices      ,    [0, 1] )
  
  				# Only out_features set
  				SCREAMING_SNAKE_CASE    	=   config_class(out_features=['''stage1''', '''stage3'''] )
  				self.assertEqual(config.out_features      ,    ['''stage1''', '''stage3'''] )
  				self.assertEqual(config.out_indices      ,    [1, 3] )
  
  				# Only out_indices set
  				SCREAMING_SNAKE_CASE    	=   config_class(out_indices=[0, 2] )
  				self.assertEqual(config.out_features      ,    [config.stage_names[0], config.stage_names[2]] )
  				self.assertEqual(config.out_indices      ,    [0, 2] )
  
  				# Error raised when out_indices do not correspond to out_features
  				with self.assertRaises(lowercase ):
  							SCREAMING_SNAKE_CASE    	=   config_class(out_features=['''stage1''', '''stage2''']      ,    out_indices=[0, 2] )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Dict )		->			List[str]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							SCREAMING_SNAKE_CASE    	=   inspect.signature(model.forward )
  							# signature.parameters is an OrderedDict => so arg_names order is deterministic
  							SCREAMING_SNAKE_CASE    	=   [*signature.parameters.keys()]
  							SCREAMING_SNAKE_CASE    	=   ['''pixel_values''']
  							self.assertListEqual(arg_names[:1]      ,    lowercase )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Union[str, Any] )		->			List[Any]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							self.assertEqual(len(model.channels )      ,    len(config.out_features ) )
  							SCREAMING_SNAKE_CASE    	=   model.num_features
  							SCREAMING_SNAKE_CASE    	=   [config.stage_names.index(lowercase ) for feat in config.out_features]
  							SCREAMING_SNAKE_CASE    	=   [num_features[idx] for idx in out_indices]
  							self.assertListEqual(model.channels      ,    lowercase )
  
  							SCREAMING_SNAKE_CASE    	=   copy.deepcopy(lowercase )
  							SCREAMING_SNAKE_CASE    	=   None
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							self.assertEqual(len(model.channels )      ,    1 )
  							self.assertListEqual(model.channels      ,    [num_features[-1]] )
  
  							SCREAMING_SNAKE_CASE    	=   copy.deepcopy(lowercase )
  							SCREAMING_SNAKE_CASE    	=   None
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							self.assertEqual(len(model.channels )      ,    1 )
  							self.assertListEqual(model.channels      ,    [num_features[-1]] )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:List[str] )		->			Tuple:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self.model_tester.prepare_config_and_inputs_for_common()
  
  				for model_class in self.all_model_classes:
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							model.to(lowercase )
  							model.eval()
  							SCREAMING_SNAKE_CASE    	=   model(**lowercase )
  
  							self.assertEqual(len(result.feature_maps )      ,    len(config.out_features ) )
  							self.assertEqual(len(model.channels )      ,    len(config.out_features ) )
  							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
  							SCREAMING_SNAKE_CASE    	=   copy.deepcopy(lowercase )
  							SCREAMING_SNAKE_CASE    	=   None
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							model.to(lowercase )
  							model.eval()
  							SCREAMING_SNAKE_CASE    	=   model(**lowercase )
  
  							self.assertEqual(len(result.feature_maps )      ,    1 )
  							self.assertEqual(len(model.channels )      ,    1 )
  
  							SCREAMING_SNAKE_CASE    	=   copy.deepcopy(lowercase )
  							SCREAMING_SNAKE_CASE    	=   None
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							model.to(lowercase )
  							model.eval()
  							SCREAMING_SNAKE_CASE    	=   model(**lowercase )
  
  							self.assertEqual(len(result.feature_maps )      ,    1 )
  							self.assertEqual(len(model.channels )      ,    1 )
  
  							# Check backbone can be initialized with fresh weights
  							SCREAMING_SNAKE_CASE    	=   copy.deepcopy(lowercase )
  							SCREAMING_SNAKE_CASE    	=   False
  							SCREAMING_SNAKE_CASE    	=   model_class(lowercase )
  							model.to(lowercase )
  							model.eval()
  							SCREAMING_SNAKE_CASE    	=   model(**lowercase )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:Optional[int] )		->			Optional[int]:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self.model_tester.prepare_config_and_inputs_for_common()
  
  				for backbone_class in self.all_model_classes:
  							SCREAMING_SNAKE_CASE    	=   backbone_class(lowercase )
  
  							self.assertTrue(hasattr(lowercase      ,    '''backbone_type''' ) )
  							self.assertTrue(hasattr(lowercase      ,    '''stage_names''' ) )
  							self.assertTrue(hasattr(lowercase      ,    '''num_features''' ) )
  							self.assertTrue(hasattr(lowercase      ,    '''out_indices''' ) )
  							self.assertTrue(hasattr(lowercase      ,    '''out_features''' ) )
  							self.assertTrue(hasattr(lowercase      ,    '''out_feature_channels''' ) )
  							self.assertTrue(hasattr(lowercase      ,    '''channels''' ) )
  
  							self.assertIsInstance(backbone.backbone_type      ,    lowercase )
  							# Verify num_features has been initialized in the backbone init
  							self.assertIsNotNone(backbone.num_features )
  							self.assertTrue(len(backbone.channels ) == len(backbone.out_indices ) )
  							self.assertTrue(len(backbone.stage_names ) == len(backbone.num_features ) )
  							self.assertTrue(len(backbone.channels ) <= len(backbone.num_features ) )
  							self.assertTrue(len(backbone.out_feature_channels ) == len(backbone.stage_names ) )
  
  
  
  
  
  
  
  	def    snake_case__    (    self			:List[str] )		->			int:
  
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  				SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   self.model_tester.prepare_config_and_inputs_for_common()
  				SCREAMING_SNAKE_CASE    	=   inputs_dict['''pixel_values'''].shape[0]
  
  				for backbone_class in self.all_model_classes:
  							SCREAMING_SNAKE_CASE    	=   backbone_class(lowercase )
  							backbone.to(lowercase )
  							backbone.eval()
  
  							SCREAMING_SNAKE_CASE    	=   backbone(**lowercase )
  
  							# Test default outputs and verify feature maps
  							self.assertIsInstance(outputs.feature_maps      ,    lowercase )
  							self.assertTrue(len(outputs.feature_maps ) == len(backbone.channels ) )
  							for feature_map, n_channels in zip(outputs.feature_maps      ,    backbone.channels ):
  										self.assertTrue(feature_map.shape[:2]      ,    (batch_size, n_channels) )
  							self.assertIsNone(outputs.hidden_states )
  							self.assertIsNone(outputs.attentions )
  
  							# Test output_hidden_states=True
  							SCREAMING_SNAKE_CASE    	=   backbone(**lowercase      ,    output_hidden_states=lowercase )
  							self.assertIsNotNone(outputs.hidden_states )
  							self.assertTrue(len(outputs.hidden_states )      ,    len(backbone.stage_names ) )
  							for hidden_state, n_channels in zip(outputs.hidden_states      ,    backbone.channels ):
  										self.assertTrue(hidden_state.shape[:2]      ,    (batch_size, n_channels) )
  
  							# Test output_attentions=True
  							if self.has_attentions:
  										SCREAMING_SNAKE_CASE    	=   backbone(**lowercase      ,    output_attentions=lowercase )
  										self.assertIsNotNone(outputs.attentions )
style_context: 
  import json
  
  import requests
  
  from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info
  
  
  def       a			(   a  )    ->Tuple:
  
  
  
  
  			'''simple docstring'''
  
  
  			class 						lowerCamelCase			:
  
  
  
  
  
  
  
  				def __init__(    self			:int      ,    lowercase			:List[str] )		->			None:
  
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  							assert isinstance(lowercase      ,    (bytes, str) )
  							SCREAMING_SNAKE_CASE    	=   content
  
  
  
  
  
  
  
  				def    snake_case__    (    self			:Optional[Any] )		->			Optional[int]:
  
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  							return json.loads(self.content )
  
  			def mock_response(*a		,	**a  ):
  						assert args[0] == AUTHENTICATED_USER_ENDPOINT
  						assert "Authorization" in kwargs["headers"]
  						assert kwargs["headers"]["Authorization"].startswith('''token '''  )
  						assert "Accept" in kwargs["headers"]
  						return FakeResponse(B'''{"login":"test","id":1}'''  )
  
  			monkeypatch.setattr(a		,	'''get'''		,	a  )
  			SCREAMING_SNAKE_CASE    	=   fetch_github_info('''token'''  )
  			assert result["login"] == "test"
  			assert result["id"] == 1