

'''simple docstring'''




import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class 							lowercase_						(		unittest.TestCase			):

  '''simple docstring'''





  def     snake_case_      (  self  )				->					List[Any]:


    """simple docstring"""
    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  )				->					List[Any]:


    """simple docstring"""
    # 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]:


    """simple docstring"""
    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 ..utils import DummyObject, requires_backends



class 							lowercase_						(		metaclass=a			):

  '''simple docstring'''





  __lowerCAmelCase       :			str     	= ["keras_nlp"]
  def __init__(  self ,			*a_ ,			**a_  )				->					Union[str, Any]:


    """simple docstring"""
    requires_backends(self ,			['keras_nlp']  )


