





"""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     snake_case_   (self		) ->   Any:
								UpperCamelCase   =	["a", "b", "c"]

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

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


						def     snake_case_   (self		) ->   str:
								# 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     snake_case_   (self		) ->   Union[str, Any]:
								UpperCamelCase   =	BackboneMixin()

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

								UpperCamelCase   =	[-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_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase__     			=			{
    '''configuration_blenderbot''': [
        '''BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''BlenderbotConfig''',
        '''BlenderbotOnnxConfig''',
    ],
    '''tokenization_blenderbot''': ['''BlenderbotTokenizer'''],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__     			=			['''BlenderbotTokenizerFast''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__     			=			[
						    '''BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''BlenderbotForCausalLM''',
						    '''BlenderbotForConditionalGeneration''',
						    '''BlenderbotModel''',
						    '''BlenderbotPreTrainedModel''',
						]


try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__     			=			[
						    '''TFBlenderbotForConditionalGeneration''',
						    '''TFBlenderbotModel''',
						    '''TFBlenderbotPreTrainedModel''',
						]


try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCAmelCase__     			=			[
						    '''FlaxBlenderbotForConditionalGeneration''',
						    '''FlaxBlenderbotModel''',
						    '''FlaxBlenderbotPreTrainedModel''',
						]


if TYPE_CHECKING:
						from .configuration_blenderbot import (
						    BLENDERBOT_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    BlenderbotConfig,
						    BlenderbotOnnxConfig,
						)
						from .tokenization_blenderbot import BlenderbotTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_blenderbot_fast import BlenderbotTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_blenderbot import (
												    BLENDERBOT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    BlenderbotForCausalLM,
												    BlenderbotForConditionalGeneration,
												    BlenderbotModel,
												    BlenderbotPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_blenderbot import (
												    TFBlenderbotForConditionalGeneration,
												    TFBlenderbotModel,
												    TFBlenderbotPreTrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_blenderbot import (
												    FlaxBlenderbotForConditionalGeneration,
												    FlaxBlenderbotModel,
												    FlaxBlenderbotPreTrainedModel,
												)

else:
						import sys

						lowerCAmelCase__     			=			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






