"""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







"""simple docstring"""







def       A__    (	lowercase_     :	list						)  ->							list:

   for insert_index, insert_value in enumerate(collection[1:]						):
      __lowerCamelCase    		=					insert_index
      while insert_index >= 0 and insert_value < collection[insert_index]:
         __lowerCamelCase    		=					collection[insert_index]
         insert_index -= 1
      if insert_index != temp_index:
         __lowerCamelCase    		=					insert_value
   return collection


if __name__ == "__main__":
     from doctest import testmod

     testmod()

     _SCREAMING_SNAKE_CASE	:		List[str]   =   input('''Enter numbers separated by a comma:\n''').strip()
     _SCREAMING_SNAKE_CASE	:		Optional[int]   =   [int(item) for item in user_input.split(''',''')]
     print(F"{insertion_sort(unsorted) = }")






