"""simple docstring"""







import enum
import inspect
from typing import Iterable, List, Optional, Tuple, Union






class      _SCREAMING_SNAKE_CASE							(			enum.Enum				):



   '''simple docstring'''



   __UpperCAmelCase	:							Optional[Any]    =    "timm"
   __UpperCAmelCase	:							Optional[int]    =    "transformers"



def       A__    (	lowercase_     :	Optional[Iterable[str]]      , lowercase_     :	Optional[Iterable[int]]      , lowercase_     :	Optional[Iterable[str]]						)  ->							Dict:
   if stage_names is None:
      raise ValueError('Stage_names must be set for transformers backbones'						)

   if out_features is not None:
      if not isinstance(lowercase_      , (list,)						):
         raise ValueError(F'''out_features must be a list {type(lowercase_						)}'''						)
      if any(feat not in stage_names for feat in out_features						):
         raise ValueError(F'''out_features must be a subset of stage_names: {stage_names} got {out_features}'''						)

   if out_indices is not None:
      if not isinstance(lowercase_      , (list, tuple)						):
         raise ValueError(F'''out_indices must be a list or tuple, got {type(lowercase_						)}'''						)
      if any(idx >= len(lowercase_						) for idx in out_indices						):
         raise ValueError('out_indices must be valid indices for stage_names {stage_names}, got {out_indices}'						)

   if out_features is not None and out_indices is not None:
      if len(lowercase_						) != len(lowercase_						):
         raise ValueError('out_features and out_indices should have the same length if both are set'						)
      if out_features != [stage_names[idx] for idx in out_indices]:
         raise ValueError('out_features and out_indices should correspond to the same stages if both are set'						)



def       A__    (	lowercase_     :	Optional[List[str]]      , lowercase_     :	Optional[Union[List[int], Tuple[int]]]      , lowercase_     :	List[str]      , )  ->							Optional[int]:
   if out_indices is None and out_features is None:
      __lowerCamelCase    		=					[len(lowercase_						) - 1]
      __lowerCamelCase    		=					[stage_names[-1]]
   elif out_indices is None and out_features is not None:
      __lowerCamelCase    		=					[stage_names.index(lowercase_						) for layer in out_features]
   elif out_features is None and out_indices is not None:
      __lowerCamelCase    		=					[stage_names[idx] for idx in out_indices]
   return out_features, out_indices



def       A__    (	lowercase_     :	Optional[List[str]]      , lowercase_     :	Optional[Union[List[int], Tuple[int]]]      , lowercase_     :	List[str]      , )  ->							Tuple[List[str], List[int]]:
   verify_out_features_out_indices(out_features=lowercase_      , out_indices=lowercase_      , stage_names=lowercase_						)
   __lowerCamelCase		,__lowerCamelCase    		=					_align_output_features_output_indices(
       out_features=lowercase_      , out_indices=lowercase_      , stage_names=lowercase_						)
   # Verify that the aligned out_features and out_indices are valid
   verify_out_features_out_indices(out_features=lowercase_      , out_indices=lowercase_      , stage_names=lowercase_						)
   return output_features, output_indices






class      _SCREAMING_SNAKE_CASE							:



   '''simple docstring'''



   __UpperCAmelCase	:							Optional[BackboneType]    =    None







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      if getattr(self ,				'_backbone' ,				_SCREAMING_SNAKE_CASE	) is None:
         raise ValueError('self._backbone must be set before calling _init_timm_backbone'	)

      # These will diagree with the defaults for the transformers models e.g. for resnet50
      # the transformer model has out_features = ['stem', 'stage1', 'stage2', 'stage3', 'stage4']
      # the timm model has out_features = ['act', 'layer1', 'layer2', 'layer3', 'layer4']
      __lowerCamelCase    		=					[stage['module'] for stage in self._backbone.feature_info.info]
      __lowerCamelCase    		=					[stage['num_chs'] for stage in self._backbone.feature_info.info]
      __lowerCamelCase    		=					self._backbone.feature_info.out_indices
      __lowerCamelCase    		=					self._backbone.feature_info.module_name()

      # We verify the out indices and out features are valid
      verify_out_features_out_indices(
          out_features=_SCREAMING_SNAKE_CASE ,				out_indices=_SCREAMING_SNAKE_CASE ,				stage_names=self.stage_names	)
      __lowerCamelCase		,__lowerCamelCase    		=					out_features, out_indices







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					getattr(_SCREAMING_SNAKE_CASE ,				'stage_names'	)
      __lowerCamelCase    		=					getattr(_SCREAMING_SNAKE_CASE ,				'out_features' ,				_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					getattr(_SCREAMING_SNAKE_CASE ,				'out_indices' ,				_SCREAMING_SNAKE_CASE	)

      __lowerCamelCase    		=					stage_names
      __lowerCamelCase		,__lowerCamelCase    		=					get_aligned_output_features_output_indices(
          out_features=_SCREAMING_SNAKE_CASE ,				out_indices=_SCREAMING_SNAKE_CASE ,				stage_names=_SCREAMING_SNAKE_CASE	)
      # Number of channels for each stage. This is set in the transformer backbone model init
      __lowerCamelCase    		=					None







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					config

      __lowerCamelCase    		=					getattr(_SCREAMING_SNAKE_CASE ,				'use_timm_backbone' ,				_SCREAMING_SNAKE_CASE	)
      __lowerCamelCase    		=					BackboneType.TIMM if self.use_timm_backbone else BackboneType.TRANSFORMERS

      if self.backbone_type == BackboneType.TIMM:
         self._init_timm_backbone(_SCREAMING_SNAKE_CASE	)
      elif self.backbone_type == BackboneType.TRANSFORMERS:
         self._init_transformers_backbone(_SCREAMING_SNAKE_CASE	)
      else:
         raise ValueError(F'''backbone_type {self.backbone_type} not supported.'''	)







   @property
   def    _A				(	self	):


      '''simple docstring'''

      return self._out_features







   @out_features.setter
   def    _A				(	self ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					get_aligned_output_features_output_indices(
          out_features=_SCREAMING_SNAKE_CASE ,				out_indices=_SCREAMING_SNAKE_CASE ,				stage_names=self.stage_names	)







   @property
   def    _A				(	self	):


      '''simple docstring'''

      return self._out_indices







   @out_indices.setter
   def    _A				(	self ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					get_aligned_output_features_output_indices(
          out_features=_SCREAMING_SNAKE_CASE ,				out_indices=_SCREAMING_SNAKE_CASE ,				stage_names=self.stage_names	)







   @property
   def    _A				(	self	):


      '''simple docstring'''

      return {stage: self.num_features[i] for i, stage in enumerate(self.stage_names	)}







   @property
   def    _A				(	self	):


      '''simple docstring'''

      return [self.out_feature_channels[name] for name in self.out_features]







   def    _A				(	self ,				*_SCREAMING_SNAKE_CASE ,				**_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase    		=					dict(inspect.signature(self.forward	).parameters	)
      __lowerCamelCase    		=					{k: v for k, v in kwargs.items() if k in signature}
      return self(*_SCREAMING_SNAKE_CASE ,				**_SCREAMING_SNAKE_CASE	)







   def    _A				(	self ,				_SCREAMING_SNAKE_CASE ,				_SCREAMING_SNAKE_CASE = None ,				_SCREAMING_SNAKE_CASE = None ,				_SCREAMING_SNAKE_CASE = None ,				):


      '''simple docstring'''

      raise NotImplementedError('This method should be implemented by the derived class.'	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					super().to_dict()
      __lowerCamelCase    		=					output.pop('_out_features'	)
      __lowerCamelCase    		=					output.pop('_out_indices'	)
      return output






class      _SCREAMING_SNAKE_CASE							:



   '''simple docstring'''



   @property
   def    _A				(	self	):


      '''simple docstring'''

      return self._out_features







   @out_features.setter
   def    _A				(	self ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					get_aligned_output_features_output_indices(
          out_features=_SCREAMING_SNAKE_CASE ,				out_indices=_SCREAMING_SNAKE_CASE ,				stage_names=self.stage_names	)







   @property
   def    _A				(	self	):


      '''simple docstring'''

      return self._out_indices







   @out_indices.setter
   def    _A				(	self ,				_SCREAMING_SNAKE_CASE	):


      '''simple docstring'''

      __lowerCamelCase		,__lowerCamelCase    		=					get_aligned_output_features_output_indices(
          out_features=_SCREAMING_SNAKE_CASE ,				out_indices=_SCREAMING_SNAKE_CASE ,				stage_names=self.stage_names	)







   def    _A				(	self	):


      '''simple docstring'''

      __lowerCamelCase    		=					super().to_dict()
      __lowerCamelCase    		=					output.pop('_out_features'	)
      __lowerCamelCase    		=					output.pop('_out_indices'	)
      return output













from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCAmelCase 	=      {"configuration_visual_bert": ["VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "VisualBertConfig"]}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				__lowerCAmelCase 	=      [
				    "VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "VisualBertForMultipleChoice",
				    "VisualBertForPreTraining",
				    "VisualBertForQuestionAnswering",
				    "VisualBertForRegionToPhraseAlignment",
				    "VisualBertForVisualReasoning",
				    "VisualBertLayer",
				    "VisualBertModel",
				    "VisualBertPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_visual_bert import (
								    VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VisualBertForMultipleChoice,
								    VisualBertForPreTraining,
								    VisualBertForQuestionAnswering,
								    VisualBertForRegionToPhraseAlignment,
								    VisualBertForVisualReasoning,
								    VisualBertLayer,
								    VisualBertModel,
								    VisualBertPreTrainedModel,
								)


else:
				import sys

				__lowerCAmelCase 	=      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





