






import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)





class     SCREAMING_SNAKE_CASE					(			unittest.TestCase       ):





							"""simple docstring"""

							def    __A			(	self: Union[str, Any] )     ->					List[Any]:
												_A										=			['''a''', '''b''', '''c''']

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

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

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

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

							def    __A			(	self: Optional[Any] )     ->					List[Any]:
												# Stage names must be set
												with self.assertRaises(a_ ):
																	verify_out_features_out_indices(['''a''', '''b''']		,  (0, 1)		,  a_ )

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

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

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

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

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

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

												# Out features and out indices should be in order
												with self.assertRaises(a_ ):
																	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    __A			(	self: Tuple )     ->					Union[str, Any]:
												_A										=			BackboneMixin()

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

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






'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import _LazyModule


_a					:			Tuple							=    {'processing_wav2vec2_with_lm': ['Wav2Vec2ProcessorWithLM']}


if TYPE_CHECKING:
  from .processing_wavaveca_with_lm import WavaVecaProcessorWithLM
else:
  import sys

  _a					:			int							=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


