
'''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			):




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= ['''a''', '''b''', '''c''']

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

								# Out indices set to match out features
								_SCREAMING_SNAKE_CASE				= 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
								_SCREAMING_SNAKE_CASE				= 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
								_SCREAMING_SNAKE_CASE				= get_aligned_output_features_output_indices(UpperCamelCase					,						[-3, -1]					,						UpperCamelCase      )
								self.assertEqual(UpperCamelCase					,						["a", "c"]      )
								self.assertEqual(UpperCamelCase					,						[-3, -1]      )




		def     lowercase       (				self      ):
								# Stage names must be set
								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     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= BackboneMixin()

								_SCREAMING_SNAKE_CASE				= ['''a''', '''b''', '''c''']
								_SCREAMING_SNAKE_CASE				= ['''a''', '''c''']
								_SCREAMING_SNAKE_CASE				= [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
								_SCREAMING_SNAKE_CASE				= ['''a''', '''b''']
								self.assertEqual(backbone.out_features					,						["a", "b"]      )
								self.assertEqual(backbone.out_indices					,						[0, 1]      )

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

'''simple docstring'''







# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
_snake_case				:   Optional[Any]     =				abspath(join(dirname(dirname(dirname(__file__))), """src"""))
sys.path.insert(1, git_repo_path)


# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="""ignore""", category=FutureWarning)



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Tuple  ):
						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(_SCREAMING_SNAKE_CASE  )




def 			_a		(	_SCREAMING_SNAKE_CASE		:   Union[str, Any]  ):
						from transformers.testing_utils import pytest_terminal_summary_main

						_SCREAMING_SNAKE_CASE				= terminalreporter.config.getoption("--make-reports"  )
						if make_reports:
												pytest_terminal_summary_main(_SCREAMING_SNAKE_CASE	,			id=_SCREAMING_SNAKE_CASE  )