






import unittest

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



class 				_UpperCamelCase      (unittest.TestCase      ):


      def 			__UpperCAmelCase		(						self						)->						Optional[Any]:
           __lowerCAmelCase             =       ['a', 'b', 'c']

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

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

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

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


      def 			__UpperCAmelCase		(						self						)->						Tuple:







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

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

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

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

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

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

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

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

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

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










'''simple docstring'''
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp


def       _lowercase							(					):
 __A	:		List[Any]	  =      ArgumentParser(
     description=(
         'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
     )      )

 # Optional arguments for the launch helper
 parser.add_argument('--num_cores',					type=UpperCamelCase__,					default=1,					help='Number of TPU cores to use (1 or 8).'      )

 # positional
 parser.add_argument(
     'training_script',					type=UpperCamelCase__,					help=(
         'The full path to the single TPU training '
         'program/script to be launched in parallel, '
         'followed by all the arguments for the '
         'training script'
     ),					)

 # rest from the training program
 parser.add_argument('training_script_args',					nargs=UpperCamelCase__      )

 return parser.parse_args()


def       _lowercase							(					):
 __A	:		str	  =      parse_args()

 # Import training_script as a module.
 __A	:		Tuple	  =      Path(args.training_script      )
 sys.path.append(str(script_fpath.parent.resolve()      )      )
 __A	:		str	  =      script_fpath.stem
 __A	:		Dict	  =      importlib.import_module(UpperCamelCase__      )

 # Patch sys.argv
 __A	:		Optional[Any]	  =      [args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores      )]

 xmp.spawn(mod._mp_fn,					args=(),					nprocs=args.num_cores      )


if __name__ == "__main__":
 main()






