

'''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					):



 """simple docstring"""



 def       UpperCAmelCase__		(		self					:       int			)  -> Any:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      ["""a""", """b""", """c"""]

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

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

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

      # Out features selected from negative indices
      __SCREAMING_SNAKE_CASE   ,			__SCREAMING_SNAKE_CASE     =      get_aligned_output_features_output_indices(__SCREAMING_SNAKE_CASE					,							[-3, -1]					,							__SCREAMING_SNAKE_CASE			)
      self.assertEqual(__SCREAMING_SNAKE_CASE					,							["""a""", """c"""]			)
      self.assertEqual(__SCREAMING_SNAKE_CASE					,							[-3, -1]			)
 def       UpperCAmelCase__		(		self					:       int			)  -> Any:


      """simple docstring"""




      with self.assertRaises(__SCREAMING_SNAKE_CASE			):
           verify_out_features_out_indices(["""a""", """b"""]					,							(0, 1)					,							__SCREAMING_SNAKE_CASE			)

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

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

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

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

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

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

      # Out features and out indices should be in order
      with self.assertRaises(__SCREAMING_SNAKE_CASE			):
           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       UpperCAmelCase__		(		self					:       List[Any]			)  -> str:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      BackboneMixin()

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

      __SCREAMING_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_torch_available


UpperCAmelCase :       Union[str, Any]			   =     {'configuration_sew': ['SEW_PRETRAINED_CONFIG_ARCHIVE_MAP', 'SEWConfig']}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase :       Union[str, Any]			   =     [
      'SEW_PRETRAINED_MODEL_ARCHIVE_LIST',
      'SEWForCTC',
      'SEWForSequenceClassification',
      'SEWModel',
      'SEWPreTrainedModel',
  ]

if TYPE_CHECKING:
  from .configuration_sew import SEW_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWConfig

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_sew import (
        SEW_PRETRAINED_MODEL_ARCHIVE_LIST,
        SEWForCTC,
        SEWForSequenceClassification,
        SEWModel,
        SEWPreTrainedModel,
    )


else:
  import sys

  UpperCAmelCase :       int			   =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






