






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	):
							def lowerCAmelCase_ (     self:      str						)		->		int:
											snake_case__									=     ['a', 'b', 'c']

											# Defaults to last layer if both are None
											snake_case__							,						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
											snake_case__							,						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
											snake_case__							,						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
											snake_case__							,						snake_case__									=     get_aligned_output_features_output_indices(UpperCamelCase       ,	[-3, -1]       ,	UpperCamelCase						)
											self.assertEqual(UpperCamelCase       ,	['a', 'c']						)
											self.assertEqual(UpperCamelCase       ,	[-3, -1]						)
							def lowerCAmelCase_ (     self:      List[str]						)		->		Tuple:
											# 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 lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Tuple:
											snake_case__									=     BackboneMixin()

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

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












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


__UpperCamelCase					:		str	  =						{}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase					:		Dict	  =						["""BartphoTokenizer"""]

if TYPE_CHECKING:
							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_bartpho import BartphoTokenizer

else:
							import sys

							__UpperCamelCase					:		Any	  =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




