



import unittest

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







class 	UpperCAmelCase	(		unittest.TestCase):


 '''simple docstring'''




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







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

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

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

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

      # Out features selected from negative indices
      a_		,						a_       		=get_aligned_output_features_output_indices(lowerCAmelCase_							,  [-3, -1]							,  lowerCAmelCase_)
      self.assertEqual(lowerCAmelCase_							,  ["a", "c"])
      self.assertEqual(lowerCAmelCase_							,  [-3, -1])




 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







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

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

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

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

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

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

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

      # Out features and out indices should be in order
      with self.assertRaises(lowerCAmelCase_):
           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       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







      a_       		=BackboneMixin()

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

      a_       		=[-3, -1]
      self.assertEqual(backbone.out_features							,  ["a", "c"])
      self.assertEqual(backbone.out_indices							,  [-3, -1])







'''simple docstring'''


from __future__ import annotations






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     if b == 0:
          return (1, 0)
     ((a_)		,						(a_))       		=extended_euclid(lowercase__       ,	a % b       )
     a_       		=a // b
     return (y, x - k * y)






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ,	lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     ((a_)		,						(a_))       		=extended_euclid(lowercase__       ,	lowercase__       )
     a_       		=na * na
     a_       		=ra * x * na + ra * y * na
     return (n % m + m) % m






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     ((a_)		,						(a_))       		=extended_euclid(lowercase__       ,	lowercase__       )
     if b < 0:
          a_       		=(b % n + n) % n
     return b






def  UpperCAmelCase_       (		lowercase__       ,	lowercase__       ,	lowercase__       ,	lowercase__       ):


     '''simple docstring'''







     a_		,						a_       		=invert_modulo(lowercase__       ,	lowercase__       ), invert_modulo(lowercase__       ,	lowercase__       )
     a_       		=na * na
     a_       		=ra * x * na + ra * y * na
     return (n % m + m) % m


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

  testmod(name='''chinese_remainder_theorem''', verbose=True)
  testmod(name='''chinese_remainder_theorem2''', verbose=True)
  testmod(name='''invert_modulo''', verbose=True)
  testmod(name='''extended_euclid''', verbose=True)


