
'''simple docstring'''







import unittest

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


class 						__UpperCAmelCase      (					unittest.TestCase						):


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






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

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

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

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

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


							def  lowerCamelCase				(       self  ):





								"""simple docstring"""






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

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

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

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

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

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

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

								# Out features and out indices should be in order
								with self.assertRaises(lowerCAmelCase_  ):
									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  ):





								"""simple docstring"""






								_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]  )



'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowercase    :							Tuple      =					{
    "configuration_xlm": ["XLM_PRETRAINED_CONFIG_ARCHIVE_MAP", "XLMConfig", "XLMOnnxConfig"],
    "tokenization_xlm": ["XLMTokenizer"],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase    :							int      =					[
					    "XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "XLMForMultipleChoice",
					    "XLMForQuestionAnswering",
					    "XLMForQuestionAnsweringSimple",
					    "XLMForSequenceClassification",
					    "XLMForTokenClassification",
					    "XLMModel",
					    "XLMPreTrainedModel",
					    "XLMWithLMHeadModel",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase    :							Tuple      =					[
					    "TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "TFXLMForMultipleChoice",
					    "TFXLMForQuestionAnsweringSimple",
					    "TFXLMForSequenceClassification",
					    "TFXLMForTokenClassification",
					    "TFXLMMainLayer",
					    "TFXLMModel",
					    "TFXLMPreTrainedModel",
					    "TFXLMWithLMHeadModel",
					]


if TYPE_CHECKING:
					from .configuration_xlm import XLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XLMConfig, XLMOnnxConfig
					from .tokenization_xlm import XLMTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_xlm import (
										    XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
										    XLMForMultipleChoice,
										    XLMForQuestionAnswering,
										    XLMForQuestionAnsweringSimple,
										    XLMForSequenceClassification,
										    XLMForTokenClassification,
										    XLMModel,
										    XLMPreTrainedModel,
										    XLMWithLMHeadModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_xlm import (
										    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFXLMForMultipleChoice,
										    TFXLMForQuestionAnsweringSimple,
										    TFXLMForSequenceClassification,
										    TFXLMForTokenClassification,
										    TFXLMMainLayer,
										    TFXLMModel,
										    TFXLMPreTrainedModel,
										    TFXLMWithLMHeadModel,
										)

else:
					import sys

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

