



import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType

@require_torch
class    _SCREAMING_SNAKE_CASE						:
     lowerCAmelCase       =      ()
     lowerCAmelCase       =      True





     def 						__snake_case     (							self			:				Union[str, Any]					)->Any:
      __SCREAMING_SNAKE_CASE							:     Dict							=						self.config_class

      # test default config
      __SCREAMING_SNAKE_CASE							:     List[str]							=						config_class()
      self.assertIsNotNone(_lowerCAmelCase					)
      __SCREAMING_SNAKE_CASE							:     int							=						["stem"] + [F"""stage{idx}""" for idx in range(1  ,	len(config.depths					) + 1					)]
      self.assertEqual(config.stage_names  ,	_lowerCAmelCase					)
      self.assertTrue(set(config.out_features					).issubset(set(config.stage_names					)					)					)

      # Test out_features and out_indices are correctly set
      # out_features and out_indices both None
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						config_class(out_features=_lowerCAmelCase  ,	out_indices=_lowerCAmelCase					)
      self.assertEqual(config.out_features  ,	[config.stage_names[-1]]					)
      self.assertEqual(config.out_indices  ,	[len(config.stage_names					) - 1]					)

      # out_features and out_indices both set
      __SCREAMING_SNAKE_CASE							:     int							=						config_class(out_features=["stem", "stage1"]  ,	out_indices=[0, 1]					)
      self.assertEqual(config.out_features  ,	["stem", "stage1"]					)
      self.assertEqual(config.out_indices  ,	[0, 1]					)

      # Only out_features set
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						config_class(out_features=["stage1", "stage3"]					)
      self.assertEqual(config.out_features  ,	["stage1", "stage3"]					)
      self.assertEqual(config.out_indices  ,	[1, 3]					)

      # Only out_indices set
      __SCREAMING_SNAKE_CASE							:     str							=						config_class(out_indices=[0, 2]					)
      self.assertEqual(config.out_features  ,	[config.stage_names[0], config.stage_names[2]]					)
      self.assertEqual(config.out_indices  ,	[0, 2]					)

      # Error raised when out_indices do not correspond to out_features
      with self.assertRaises(_lowerCAmelCase					):
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						config_class(out_features=["stage1", "stage2"]  ,	out_indices=[0, 2]					)





     def 						__snake_case     (							self			:				Optional[int]					)->Any:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     Any							=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __SCREAMING_SNAKE_CASE							:     int							=						model_class(_lowerCAmelCase					)
       __SCREAMING_SNAKE_CASE							:     Tuple							=						inspect.signature(model.forward					)
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       __SCREAMING_SNAKE_CASE							:     List[str]							=						[*signature.parameters.keys()]
       __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						["pixel_values"]
       self.assertListEqual(arg_names[:1]  ,	_lowerCAmelCase					)





     def 						__snake_case     (							self			:				str					)->Tuple:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     List[str]							=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model_class(_lowerCAmelCase					)
       self.assertEqual(len(model.channels					)  ,	len(config.out_features					)					)
       __SCREAMING_SNAKE_CASE							:     str							=						model.num_features
       __SCREAMING_SNAKE_CASE							:     Tuple							=						[config.stage_names.index(_lowerCAmelCase					) for feat in config.out_features]
       __SCREAMING_SNAKE_CASE							:     List[Any]							=						[num_features[idx] for idx in out_indices]
       self.assertListEqual(model.channels  ,	_lowerCAmelCase					)

       __SCREAMING_SNAKE_CASE							:     List[str]							=						copy.deepcopy(_lowerCAmelCase					)
       __SCREAMING_SNAKE_CASE							:     str							=						None
       __SCREAMING_SNAKE_CASE							:     Optional[int]							=						model_class(_lowerCAmelCase					)
       self.assertEqual(len(model.channels					)  ,	1					)
       self.assertListEqual(model.channels  ,	[num_features[-1]]					)

       __SCREAMING_SNAKE_CASE							:     str							=						copy.deepcopy(_lowerCAmelCase					)
       __SCREAMING_SNAKE_CASE							:     Dict							=						None
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model_class(_lowerCAmelCase					)
       self.assertEqual(len(model.channels					)  ,	1					)
       self.assertListEqual(model.channels  ,	[num_features[-1]]					)





     def 						__snake_case     (							self			:				List[str]					)->Any:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     List[str]							=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model_class(_lowerCAmelCase					)
       model.to(_lowerCAmelCase					)
       model.eval()
       __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						model(**_lowerCAmelCase					)

       self.assertEqual(len(result.feature_maps					)  ,	len(config.out_features					)					)
       self.assertEqual(len(model.channels					)  ,	len(config.out_features					)					)
       self.assertEqual(len(result.feature_maps					)  ,	len(config.out_indices					)					)
       self.assertEqual(len(model.channels					)  ,	len(config.out_indices					)					)

       # Check output of last stage is taken if out_features=None, out_indices=None
       __SCREAMING_SNAKE_CASE							:     Optional[int]							=						copy.deepcopy(_lowerCAmelCase					)
       __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						None
       __SCREAMING_SNAKE_CASE							:     Optional[int]							=						model_class(_lowerCAmelCase					)
       model.to(_lowerCAmelCase					)
       model.eval()
       __SCREAMING_SNAKE_CASE							:     str							=						model(**_lowerCAmelCase					)

       self.assertEqual(len(result.feature_maps					)  ,	1					)
       self.assertEqual(len(model.channels					)  ,	1					)

       __SCREAMING_SNAKE_CASE							:     str							=						copy.deepcopy(_lowerCAmelCase					)
       __SCREAMING_SNAKE_CASE							:     str							=						None
       __SCREAMING_SNAKE_CASE							:     Optional[int]							=						model_class(_lowerCAmelCase					)
       model.to(_lowerCAmelCase					)
       model.eval()
       __SCREAMING_SNAKE_CASE							:     List[Any]							=						model(**_lowerCAmelCase					)

       self.assertEqual(len(result.feature_maps					)  ,	1					)
       self.assertEqual(len(model.channels					)  ,	1					)

       # Check backbone can be initialized with fresh weights
       __SCREAMING_SNAKE_CASE							:     List[str]							=						copy.deepcopy(_lowerCAmelCase					)
       __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						False
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model_class(_lowerCAmelCase					)
       model.to(_lowerCAmelCase					)
       model.eval()
       __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						model(**_lowerCAmelCase					)





     def 						__snake_case     (							self			:				int					)->Optional[int]:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     str							=						self.model_tester.prepare_config_and_inputs_for_common()

      for backbone_class in self.all_model_classes:
       __SCREAMING_SNAKE_CASE							:     List[Any]							=						backbone_class(_lowerCAmelCase					)

       self.assertTrue(hasattr(_lowerCAmelCase  ,	"backbone_type"					)					)
       self.assertTrue(hasattr(_lowerCAmelCase  ,	"stage_names"					)					)
       self.assertTrue(hasattr(_lowerCAmelCase  ,	"num_features"					)					)
       self.assertTrue(hasattr(_lowerCAmelCase  ,	"out_indices"					)					)
       self.assertTrue(hasattr(_lowerCAmelCase  ,	"out_features"					)					)
       self.assertTrue(hasattr(_lowerCAmelCase  ,	"out_feature_channels"					)					)
       self.assertTrue(hasattr(_lowerCAmelCase  ,	"channels"					)					)

       self.assertIsInstance(backbone.backbone_type  ,	_lowerCAmelCase					)
       # Verify num_features has been initialized in the backbone init
       self.assertIsNotNone(backbone.num_features					)
       self.assertTrue(len(backbone.channels					) == len(backbone.out_indices					)					)
       self.assertTrue(len(backbone.stage_names					) == len(backbone.num_features					)					)
       self.assertTrue(len(backbone.channels					) <= len(backbone.num_features					)					)
       self.assertTrue(len(backbone.out_feature_channels					) == len(backbone.stage_names					)					)






     def 						__snake_case     (							self			:				Optional[Any]					)->Optional[Any]:
      __SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							:     Optional[int]							=						self.model_tester.prepare_config_and_inputs_for_common()
      __SCREAMING_SNAKE_CASE							:     int							=						inputs_dict["pixel_values"].shape[0]

      for backbone_class in self.all_model_classes:
       __SCREAMING_SNAKE_CASE							:     str							=						backbone_class(_lowerCAmelCase					)
       backbone.to(_lowerCAmelCase					)
       backbone.eval()

       __SCREAMING_SNAKE_CASE							:     int							=						backbone(**_lowerCAmelCase					)

       # Test default outputs and verify feature maps
       self.assertIsInstance(outputs.feature_maps  ,	_lowerCAmelCase					)
       self.assertTrue(len(outputs.feature_maps					) == len(backbone.channels					)					)
       for feature_map, n_channels in zip(outputs.feature_maps  ,	backbone.channels					):
        self.assertTrue(feature_map.shape[:2]  ,	(batch_size, n_channels)					)
       self.assertIsNone(outputs.hidden_states					)
       self.assertIsNone(outputs.attentions					)

       # Test output_hidden_states=True
       __SCREAMING_SNAKE_CASE							:     List[Any]							=						backbone(**_lowerCAmelCase  ,	output_hidden_states=_lowerCAmelCase					)
       self.assertIsNotNone(outputs.hidden_states					)
       self.assertTrue(len(outputs.hidden_states					)  ,	len(backbone.stage_names					)					)
       for hidden_state, n_channels in zip(outputs.hidden_states  ,	backbone.channels					):
        self.assertTrue(hidden_state.shape[:2]  ,	(batch_size, n_channels)					)

       # Test output_attentions=True
       if self.has_attentions:
        __SCREAMING_SNAKE_CASE							:     str							=						backbone(**_lowerCAmelCase  ,	output_attentions=_lowerCAmelCase					)
        self.assertIsNotNone(outputs.attentions					)










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase			:					Optional[int]         =							{
    '''configuration_dpr''': ['''DPR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DPRConfig'''],
    '''tokenization_dpr''': [
        '''DPRContextEncoderTokenizer''',
        '''DPRQuestionEncoderTokenizer''',
        '''DPRReaderOutput''',
        '''DPRReaderTokenizer''',
    ],
}


try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase			:					List[str]         =							[
					    '''DPRContextEncoderTokenizerFast''',
					    '''DPRQuestionEncoderTokenizerFast''',
					    '''DPRReaderTokenizerFast''',
					]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase			:					Optional[Any]         =							[
					    '''DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''DPRContextEncoder''',
					    '''DPRPretrainedContextEncoder''',
					    '''DPRPreTrainedModel''',
					    '''DPRPretrainedQuestionEncoder''',
					    '''DPRPretrainedReader''',
					    '''DPRQuestionEncoder''',
					    '''DPRReader''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase			:					Optional[int]         =							[
					    '''TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFDPRContextEncoder''',
					    '''TFDPRPretrainedContextEncoder''',
					    '''TFDPRPretrainedQuestionEncoder''',
					    '''TFDPRPretrainedReader''',
					    '''TFDPRQuestionEncoder''',
					    '''TFDPRReader''',
					]


if TYPE_CHECKING:
					from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
					from .tokenization_dpr import (
					    DPRContextEncoderTokenizer,
					    DPRQuestionEncoderTokenizer,
					    DPRReaderOutput,
					    DPRReaderTokenizer,
					)

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_dpr_fast import (
										    DPRContextEncoderTokenizerFast,
										    DPRQuestionEncoderTokenizerFast,
										    DPRReaderTokenizerFast,
										)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_dpr import (
										    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPRContextEncoder,
										    DPRPretrainedContextEncoder,
										    DPRPreTrainedModel,
										    DPRPretrainedQuestionEncoder,
										    DPRPretrainedReader,
										    DPRQuestionEncoder,
										    DPRReader,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_dpr import (
										    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFDPRContextEncoder,
										    TFDPRPretrainedContextEncoder,
										    TFDPRPretrainedQuestionEncoder,
										    TFDPRPretrainedReader,
										    TFDPRQuestionEncoder,
										    TFDPRReader,
										)

else:
					import sys

					UpperCamelCase			:					List[Any]         =							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

