


'''simple docstring'''

import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)
class     __lowerCAmelCase		(unittest.TestCase	):





      '''simple docstring'''






      def  UpperCamelCase__						(self       :       List[Any]					):

             '''simple docstring'''







             lowercase__      =					['''a''', '''b''', '''c''']

             # Defaults to last layer if both are None
             lowercase__     ,lowercase__      =					get_aligned_output_features_output_indices(UpperCamelCase  ,		UpperCamelCase  ,		UpperCamelCase					)
             self.assertEqual(UpperCamelCase  ,		['''c''']					)
             self.assertEqual(UpperCamelCase  ,		[2]					)

             # Out indices set to match out features
             lowercase__     ,lowercase__      =					get_aligned_output_features_output_indices(['''a''', '''c''']  ,		UpperCamelCase  ,		UpperCamelCase					)
             self.assertEqual(UpperCamelCase  ,		['''a''', '''c''']					)
             self.assertEqual(UpperCamelCase  ,		[0, 2]					)

             # Out features set to match out indices
             lowercase__     ,lowercase__      =					get_aligned_output_features_output_indices(UpperCamelCase  ,		[0, 2]  ,		UpperCamelCase					)
             self.assertEqual(UpperCamelCase  ,		['''a''', '''c''']					)
             self.assertEqual(UpperCamelCase  ,		[0, 2]					)

             # Out features selected from negative indices
             lowercase__     ,lowercase__      =					get_aligned_output_features_output_indices(UpperCamelCase  ,		[-3, -1]  ,		UpperCamelCase					)
             self.assertEqual(UpperCamelCase  ,		['''a''', '''c''']					)
             self.assertEqual(UpperCamelCase  ,		[-3, -1]					)



      def  UpperCamelCase__						(self       :       Dict					):

             '''simple docstring'''







             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(['''a''', '''b''']  ,		(0, 1)  ,		UpperCamelCase					)

             # Out features must be a list
             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(('''a''', '''b''')  ,		(0, 1)  ,		['''a''', '''b''']					)

             # Out features must be a subset of stage names
             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(['''a''', '''b''']  ,		(0, 1)  ,		['''a''']					)

             # Out indices must be a list or tuple
             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(UpperCamelCase  ,		0  ,		['''a''', '''b''']					)

             # Out indices must be a subset of stage names
             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(UpperCamelCase  ,		(0, 1)  ,		['''a''']					)

             # Out features and out indices must be the same length
             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(['''a''', '''b''']  ,		(0,)  ,		['''a''', '''b''', '''c''']					)

             # Out features should match out indices
             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(['''a''', '''b''']  ,		(0, 2)  ,		['''a''', '''b''', '''c''']					)

             # Out features and out indices should be in order
             with self.assertRaises(UpperCamelCase					):
                    verify_out_features_out_indices(['''b''', '''a''']  ,		(0, 1)  ,		['''a''', '''b''']					)

             # Check passes with valid inputs
             verify_out_features_out_indices(['''a''', '''b''', '''d''']  ,		(0, 1, -1)  ,		['''a''', '''b''', '''c''', '''d''']					)






      def  UpperCamelCase__						(self       :       Union[str, Any]					):

             '''simple docstring'''







             lowercase__      =					BackboneMixin()

             lowercase__      =					['''a''', '''b''', '''c''']
             lowercase__      =					['''a''', '''c''']
             lowercase__      =					[0, 2]

             # Check that the output features and indices are set correctly
             self.assertEqual(backbone.out_features  ,		['''a''', '''c''']					)
             self.assertEqual(backbone.out_indices  ,		[0, 2]					)

             # Check out features and indices are updated correctly
             lowercase__      =					['''a''', '''b''']
             self.assertEqual(backbone.out_features  ,		['''a''', '''b''']					)
             self.assertEqual(backbone.out_indices  ,		[0, 1]					)

             lowercase__      =					[-3, -1]
             self.assertEqual(backbone.out_features  ,		['''a''', '''c''']					)
             self.assertEqual(backbone.out_indices  ,		[-3, -1]					)








'''simple docstring'''

def _SCREAMING_SNAKE_CASE (A			)			->			bool:






       """simple docstring"""







       lowercase__      =					[int(A			) for i in ip_va_address.split('''.'''			) if i.isdigit()]
       return len(A			) == 4 and all(0 <= int(A			) <= 254 for octet in octets			)


if __name__ == "__main__":
 lowerCamelCase				:  Optional[Any]    		=      input().strip()
 lowerCamelCase				:  Union[str, Any]    		=      'valid' if is_ip_va_address_valid(ip) else 'invalid'
 print(f"""{ip} is a {valid_or_invalid} IP v4 address.""")




