
"""simple docstring"""




import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType







@require_torch
class 						lowercase:
     __snake_case:  Any  				=    ()
     __snake_case:  Optional[int]  				=    True



     def  lowercase__(       self      )		->    Any:







         """simple docstring"""



         a__    = self.config_class

         # test default config
         a__    = config_class()
         self.assertIsNotNone(__UpperCamelCase      )
         a__    = ['''stem'''] + [f'stage{idx}' for idx in range(1    ,							len(config.depths      ) + 1      )]
         self.assertEqual(config.stage_names    ,							__UpperCamelCase      )
         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
         a__    = config_class(out_features=__UpperCamelCase    ,							out_indices=__UpperCamelCase      )
         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
         a__    = 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
         a__    = config_class(out_features=['stage1', 'stage3']      )
         self.assertEqual(config.out_features    ,							['stage1', 'stage3']      )
         self.assertEqual(config.out_indices    ,							[1, 3]      )

         # Only out_indices set
         a__    = 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(__UpperCamelCase      ):
             a__    = config_class(out_features=['stage1', 'stage2']    ,							out_indices=[0, 2]      )



     def  lowercase__(       self      )		->    int:







         """simple docstring"""



         a__    = self.model_tester.prepare_config_and_inputs_for_common()

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



     def  lowercase__(       self      )		->    Tuple:







         """simple docstring"""



         a__    = self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             a__    = model_class(__UpperCamelCase      )
             self.assertEqual(len(model.channels      )    ,							len(config.out_features      )      )
             a__    = model.num_features
             a__    = [config.stage_names.index(__UpperCamelCase      ) for feat in config.out_features]
             a__    = [num_features[idx] for idx in out_indices]
             self.assertListEqual(model.channels    ,							__UpperCamelCase      )

             a__    = copy.deepcopy(__UpperCamelCase      )
             a__    = None
             a__    = model_class(__UpperCamelCase      )
             self.assertEqual(len(model.channels      )    ,							1      )
             self.assertListEqual(model.channels    ,							[num_features[-1]]      )

             a__    = copy.deepcopy(__UpperCamelCase      )
             a__    = None
             a__    = model_class(__UpperCamelCase      )
             self.assertEqual(len(model.channels      )    ,							1      )
             self.assertListEqual(model.channels    ,							[num_features[-1]]      )



     def  lowercase__(       self      )		->    str:







         """simple docstring"""



         a__    = self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             a__    = model_class(__UpperCamelCase      )
             model.to(__UpperCamelCase      )
             model.eval()
             a__    = model(**__UpperCamelCase      )

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

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

             a__    = copy.deepcopy(__UpperCamelCase      )
             a__    = None
             a__    = model_class(__UpperCamelCase      )
             model.to(__UpperCamelCase      )
             model.eval()
             a__    = model(**__UpperCamelCase      )

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

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



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







         """simple docstring"""



         a__    = self.model_tester.prepare_config_and_inputs_for_common()

         for backbone_class in self.all_model_classes:
             a__    = backbone_class(__UpperCamelCase      )

             self.assertTrue(hasattr(__UpperCamelCase    ,							'backbone_type'      )      )
             self.assertTrue(hasattr(__UpperCamelCase    ,							'stage_names'      )      )
             self.assertTrue(hasattr(__UpperCamelCase    ,							'num_features'      )      )
             self.assertTrue(hasattr(__UpperCamelCase    ,							'out_indices'      )      )
             self.assertTrue(hasattr(__UpperCamelCase    ,							'out_features'      )      )
             self.assertTrue(hasattr(__UpperCamelCase    ,							'out_feature_channels'      )      )
             self.assertTrue(hasattr(__UpperCamelCase    ,							'channels'      )      )

             self.assertIsInstance(backbone.backbone_type    ,							__UpperCamelCase      )
             # 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  lowercase__(       self      )		->    str:







         """simple docstring"""



         a__    = self.model_tester.prepare_config_and_inputs_for_common()
         a__    = inputs_dict['''pixel_values'''].shape[0]

         for backbone_class in self.all_model_classes:
             a__    = backbone_class(__UpperCamelCase      )
             backbone.to(__UpperCamelCase      )
             backbone.eval()

             a__    = backbone(**__UpperCamelCase      )

             # Test default outputs and verify feature maps
             self.assertIsInstance(outputs.feature_maps    ,							__UpperCamelCase      )
             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
             a__    = backbone(**__UpperCamelCase    ,							output_hidden_states=__UpperCamelCase      )
             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:
                 a__    = backbone(**__UpperCamelCase    ,							output_attentions=__UpperCamelCase      )
                 self.assertIsNotNone(outputs.attentions      )




"""simple docstring"""




a		:					str    	=					(1, 1_53, 3_70, 3_71, 16_34, 24_67_80_51, 1_15_13_22_19_01_87_63_99_25_65_09_55_97_97_39_71_52_24_01)
a		:					tuple    	=					(-1_53, -1, 0, 1.2, 2_00, "A", [], {}, None)



def 						__magic_name__		(				UpperCamelCase    :		int    )    ->	bool:
    if not isinstance(UpperCamelCase       ,		UpperCamelCase    ) or n < 1:
        return False

    # Initialization of sum and number of digits.
    a__    = 0
    a__    = 0
    a__    = n
    # Calculation of digits of the number
    while temp > 0:
        number_of_digits += 1
        temp //= 10
    # Dividing number into separate digits and find Armstrong number
    a__    = n
    while temp > 0:
        a__    = temp % 10
        total += rem**number_of_digits
        temp //= 10
    return n == total



def 						__magic_name__		(				UpperCamelCase    :		int    )    ->	bool:
    if not isinstance(UpperCamelCase       ,		UpperCamelCase    ) or n < 1:
        return False

    # Init a "histogram" of the digits
    a__    = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    a__    = 0
    a__    = 0
    a__    = n
    while temp > 0:
        a__  ,    a__    = divmod(UpperCamelCase       ,		10    )
        digit_histogram[rem] += 1
        digit_total += 1

    for cnt, i in zip(UpperCamelCase       ,		range(len(UpperCamelCase    )    )    ):
        total += cnt * i**digit_total

    return n == total



def 						__magic_name__		(				UpperCamelCase    :		int    )    ->	bool:
    if not isinstance(UpperCamelCase       ,		UpperCamelCase    ) or n < 1:
        return False
    a__    = len(str(UpperCamelCase    )    )  # the power that all digits will be raised to
    # check if sum of each digit multiplied expo times is equal to number
    return n == sum(int(UpperCamelCase    ) ** expo for i in str(UpperCamelCase    )    )



def 						__magic_name__		(				)    ->	List[Any]:
    a__    = int(input('Enter an integer to see if it is an Armstrong number: '    ).strip()    )
    print(f'{num} is {"" if armstrong_number(UpperCamelCase    ) else "not "}an Armstrong number.'    )
    print(f'{num} is {"" if narcissistic_number(UpperCamelCase    ) else "not "}an Armstrong number.'    )
    print(f'{num} is {"" if pluperfect_number(UpperCamelCase    ) else "not "}an Armstrong number.'    )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()


