

import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


lowercase_			=  get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
     from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

lowercase_			=  256047
lowercase_			=  256145


@require_sentencepiece
@require_tokenizers
class 			A						(							_UpperCAmelCase   ,							unittest.TestCase			):







    """simple docstring"""





    lowerCamelCase		     =							NllbTokenizer
    lowerCamelCase		     =							NllbTokenizerFast
    lowerCamelCase		     =							True
    lowerCamelCase		     =							True
    lowerCamelCase		     =							{}


    def 						snake_case__					(				self			:	Optional[int]		)->   Dict:





        '''simple docstring'''







        super().setUp()

        # We have a SentencePiece fixture for testing
        A__   				=       NllbTokenizer(lowercase_,keep_accents=lowercase_		)
        tokenizer.save_pretrained(self.tmpdirname		)


    def 						snake_case__					(				self			:	Tuple		)->   Tuple:





        '''simple docstring'''







        A__   				=       NllbTokenizer(lowercase_,keep_accents=lowercase_		)

        A__   				=       tokenizer.tokenize('This is a test'		)
        self.assertListEqual(lowercase_,['▁This', '▁is', '▁a', '▁t', 'est']		)

        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(lowercase_		),[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]],)

        A__   				=       tokenizer.tokenize('I was born in 92000, and this is falsé.'		)
        self.assertListEqual(
            lowercase_,[
                SPIECE_UNDERLINE + 'I',
                SPIECE_UNDERLINE + 'was',
                SPIECE_UNDERLINE + 'b',
                'or',
                'n',
                SPIECE_UNDERLINE + 'in',
                SPIECE_UNDERLINE + '',
                '9',
                '2',
                '0',
                '0',
                '0',
                ',',
                SPIECE_UNDERLINE + 'and',
                SPIECE_UNDERLINE + 'this',
                SPIECE_UNDERLINE + 'is',
                SPIECE_UNDERLINE + 'f',
                'al',
                's',
                'é',
                '.',
            ],)
        A__   				=       tokenizer.convert_tokens_to_ids(lowercase_		)
        self.assertListEqual(
            lowercase_,[
                value + tokenizer.fairseq_offset
                for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
            ],)

        A__   				=       tokenizer.convert_ids_to_tokens(lowercase_		)
        self.assertListEqual(
            lowercase_,[
                SPIECE_UNDERLINE + 'I',
                SPIECE_UNDERLINE + 'was',
                SPIECE_UNDERLINE + 'b',
                'or',
                'n',
                SPIECE_UNDERLINE + 'in',
                SPIECE_UNDERLINE + '',
                '<unk>',
                '2',
                '0',
                '0',
                '0',
                ',',
                SPIECE_UNDERLINE + 'and',
                SPIECE_UNDERLINE + 'this',
                SPIECE_UNDERLINE + 'is',
                SPIECE_UNDERLINE + 'f',
                'al',
                's',
                '<unk>',
                '.',
            ],)


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





        '''simple docstring'''







        A__   				=       (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {})
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'		):
                A__   				=       self.rust_tokenizer_class.from_pretrained(lowercase_,**lowercase_		)
                A__   				=       self.tokenizer_class.from_pretrained(lowercase_,**lowercase_		)

                A__   				=       tempfile.mkdtemp()

                A__   				=       tokenizer_r.save_pretrained(lowercase_		)
                A__   				=       tokenizer_p.save_pretrained(lowercase_		)

                # Checks it save with the same files + the tokenizer.json file for the fast one
                self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files		)		)
                A__   				=       tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f		)
                self.assertSequenceEqual(lowercase_,lowercase_		)

                # Checks everything loads correctly in the same way
                A__   				=       tokenizer_r.from_pretrained(lowercase_		)
                A__   				=       tokenizer_p.from_pretrained(lowercase_		)

                # Check special tokens are set accordingly on Rust and Python
                for key in tokenizer_pp.special_tokens_map:
                    self.assertTrue(hasattr(lowercase_,lowercase_		)		)

                shutil.rmtree(lowercase_		)

                # Save tokenizer rust, legacy_format=True
                A__   				=       tempfile.mkdtemp()

                A__   				=       tokenizer_r.save_pretrained(lowercase_,legacy_format=lowercase_		)
                A__   				=       tokenizer_p.save_pretrained(lowercase_		)

                # Checks it save with the same files
                self.assertSequenceEqual(lowercase_,lowercase_		)

                # Checks everything loads correctly in the same way
                A__   				=       tokenizer_r.from_pretrained(lowercase_		)
                A__   				=       tokenizer_p.from_pretrained(lowercase_		)

                # Check special tokens are set accordingly on Rust and Python
                for key in tokenizer_pp.special_tokens_map:
                    self.assertTrue(hasattr(lowercase_,lowercase_		)		)

                shutil.rmtree(lowercase_		)

                # Save tokenizer rust, legacy_format=False
                A__   				=       tempfile.mkdtemp()

                A__   				=       tokenizer_r.save_pretrained(lowercase_,legacy_format=lowercase_		)
                A__   				=       tokenizer_p.save_pretrained(lowercase_		)

                # Checks it saved the tokenizer.json file
                self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files		)		)

                # Checks everything loads correctly in the same way
                A__   				=       tokenizer_r.from_pretrained(lowercase_		)
                A__   				=       tokenizer_p.from_pretrained(lowercase_		)

                # Check special tokens are set accordingly on Rust and Python
                for key in tokenizer_pp.special_tokens_map:
                    self.assertTrue(hasattr(lowercase_,lowercase_		)		)

                shutil.rmtree(lowercase_		)


    @require_torch
    def 						snake_case__					(				self			:	Optional[Any]		)->   str:





        '''simple docstring'''







        if not self.test_seqaseq:
            return

        A__   				=       self.get_tokenizers()
        for tokenizer in tokenizers:
            with self.subTest(F'{tokenizer.__class__.__name__}'		):
                # Longer text that will definitely require truncation.
                A__   				=       [
                    ' UN Chief Says There Is No Military Solution in Syria',
                    ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'
                    ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'
                    ' will only worsen the violence and misery for millions of people.',
                ]
                A__   				=       [
                    'Şeful ONU declară că nu există o soluţie militară în Siria',
                    'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'
                    ' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'
                    ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
                ]
                try:
                    A__   				=       tokenizer.prepare_seqaseq_batch(
                        src_texts=lowercase_,tgt_texts=lowercase_,max_length=3,max_target_length=1_0,return_tensors='pt',src_lang='eng_Latn',tgt_lang='ron_Latn',)
                except NotImplementedError:
                    return
                self.assertEqual(batch.input_ids.shape[1],3		)
                self.assertEqual(batch.labels.shape[1],1_0		)
                # max_target_length will default to max_length if not specified
                A__   				=       tokenizer.prepare_seqaseq_batch(
                    lowercase_,tgt_texts=lowercase_,max_length=3,return_tensors='pt'		)
                self.assertEqual(batch.input_ids.shape[1],3		)
                self.assertEqual(batch.labels.shape[1],3		)

                A__   				=       tokenizer.prepare_seqaseq_batch(
                    src_texts=lowercase_,max_length=3,max_target_length=1_0,return_tensors='pt'		)
                self.assertEqual(batch_encoder_only.input_ids.shape[1],3		)
                self.assertEqual(batch_encoder_only.attention_mask.shape[1],3		)
                self.assertNotIn('decoder_input_ids',lowercase_		)


    @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.'		)
    def 						snake_case__					(				self			:	Tuple		)->   Optional[Any]:





        '''simple docstring'''







        pass


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





        '''simple docstring'''







        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'		):
                A__   				=       [AddedToken('<special>',lstrip=lowercase_		)]

                A__   				=       self.rust_tokenizer_class.from_pretrained(
                    lowercase_,additional_special_tokens=lowercase_,**lowercase_		)
                A__   				=       tokenizer_r.encode('Hey this is a <special> token'		)

                A__   				=       tokenizer_r.encode('<special>',add_special_tokens=lowercase_		)[0]

                self.assertTrue(special_token_id in r_output		)

                if self.test_slow_tokenizer:
                    A__   				=       self.rust_tokenizer_class.from_pretrained(
                        lowercase_,additional_special_tokens=lowercase_,**lowercase_,)
                    A__   				=       self.tokenizer_class.from_pretrained(
                        lowercase_,additional_special_tokens=lowercase_,**lowercase_		)

                    A__   				=       tokenizer_p.encode('Hey this is a <special> token'		)

                    A__   				=       tokenizer_cr.encode('Hey this is a <special> token'		)

                    self.assertEqual(lowercase_,lowercase_		)
                    self.assertEqual(lowercase_,lowercase_		)
                    self.assertTrue(special_token_id in p_output		)
                    self.assertTrue(special_token_id in cr_output		)




@require_torch
@require_sentencepiece
@require_tokenizers
class 			A						(							unittest.TestCase			):







    """simple docstring"""





    lowerCamelCase		     =							'facebook/nllb-200-distilled-600M'
    lowerCamelCase		     =							[
        ' UN Chief Says There Is No Military Solution in Syria',
        ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.',
    ]
    lowerCamelCase		     =							[
        'Şeful ONU declară că nu există o soluţie militară în Siria',
        'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'
        ' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'
        ' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
    ]
    lowerCamelCase		     =							[
        25_60_47,
        1_62_97,
        13_44_08,
        81_65,
        24_80_66,
        1_47_34,
        9_50,
        11_35,
        10_57_21,
        35_73,
        83,
        2_73_52,
        1_08,
        4_94_86,
        2,
    ]


    @classmethod
    def 						snake_case__					(				cls			:	Tuple		)->   List[str]:





        '''simple docstring'''







        A__   				=       NllbTokenizer.from_pretrained(
            cls.checkpoint_name,src_lang='eng_Latn',tgt_lang='ron_Latn'		)
        A__   				=       1
        return cls


    def 						snake_case__					(				self			:	Optional[int]		)->   Any:





        '''simple docstring'''







        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab'],2_5_6_0_0_1		)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn'],2_5_6_0_0_2		)
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn'],2_5_6_0_5_7		)


    def 						snake_case__					(				self			:	Optional[Any]		)->   List[str]:





        '''simple docstring'''







        A__   				=       self.tokenizer.batch_encode_plus(self.src_text		).input_ids[0]
        self.assertListEqual(self.expected_src_tokens,lowercase_		)


    def 						snake_case__					(				self			:	Tuple		)->   List[str]:





        '''simple docstring'''







        self.assertIn(lowercase_,self.tokenizer.all_special_ids		)
        # fmt: off
        A__   				=       [RO_CODE, 4_2_5_4, 9_8_0_6_8, 1_1_2_9_2_3, 3_9_0_7_2, 3_9_0_9, 7_1_3, 1_0_2_7_6_7, 2_6, 1_7_3_1_4, 3_5_6_4_2, 1_4_6_8_3, 3_3_1_1_8, 2_0_2_2, 6_6_9_8_7, 2, 2_5_6_0_4_7]
        # fmt: on

        A__   				=       self.tokenizer.decode(lowercase_,skip_special_tokens=lowercase_		)
        A__   				=       self.tokenizer.decode(generated_ids[1:],skip_special_tokens=lowercase_		)
        self.assertEqual(lowercase_,lowercase_		)
        self.assertNotIn(self.tokenizer.eos_token,lowercase_		)


    def 						snake_case__					(				self			:	Tuple		)->   Dict:





        '''simple docstring'''







        A__   				=       ['this is gunna be a long sentence ' * 2_0]
        assert isinstance(src_text[0],lowercase_		)
        A__   				=       1_0
        A__   				=       self.tokenizer(lowercase_,max_length=lowercase_,truncation=lowercase_		).input_ids[0]
        self.assertEqual(ids[-1],2		)
        self.assertEqual(ids[0],lowercase_		)
        self.assertEqual(len(lowercase_		),lowercase_		)


    def 						snake_case__					(				self			:	Dict		)->   Optional[Any]:





        '''simple docstring'''







        self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']		),[2_5_6_2_0_3, 3]		)


    def 						snake_case__					(				self			:	str		)->   Optional[Any]:





        '''simple docstring'''







        A__   				=       tempfile.mkdtemp()
        A__   				=       self.tokenizer.fairseq_tokens_to_ids
        self.tokenizer.save_pretrained(lowercase_		)
        A__   				=       NllbTokenizer.from_pretrained(lowercase_		)
        self.assertDictEqual(new_tok.fairseq_tokens_to_ids,lowercase_		)


    @require_torch
    def 						snake_case__					(				self			:	Tuple		)->   Dict:





        '''simple docstring'''







        A__   				=       self.tokenizer(
            self.src_text,text_target=self.tgt_text,padding=lowercase_,truncation=lowercase_,max_length=len(self.expected_src_tokens		),return_tensors='pt',)
        A__   				=       shift_tokens_right(
            batch['labels'],self.tokenizer.pad_token_id,self.tokenizer.lang_code_to_id['ron_Latn']		)

        self.assertIsInstance(lowercase_,lowercase_		)

        self.assertEqual((2, 1_5),batch.input_ids.shape		)
        self.assertEqual((2, 1_5),batch.attention_mask.shape		)
        A__   				=       batch.input_ids.tolist()[0]
        self.assertListEqual(self.expected_src_tokens,lowercase_		)
        self.assertEqual(lowercase_,batch.decoder_input_ids[0, 0]		)  # EOS
        # Test that special tokens are reset
        self.assertEqual(self.tokenizer.prefix_tokens,[EN_CODE]		)
        self.assertEqual(self.tokenizer.suffix_tokens,[self.tokenizer.eos_token_id]		)


    def 						snake_case__					(				self			:	List[str]		)->   Tuple:





        '''simple docstring'''







        A__   				=       self.tokenizer(self.src_text,padding=lowercase_,truncation=lowercase_,max_length=3,return_tensors='pt'		)
        A__   				=       self.tokenizer(
            text_target=self.tgt_text,padding=lowercase_,truncation=lowercase_,max_length=1_0,return_tensors='pt'		)
        A__   				=       targets['input_ids']
        A__   				=       shift_tokens_right(
            lowercase_,self.tokenizer.pad_token_id,decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang],)

        self.assertEqual(batch.input_ids.shape[1],3		)
        self.assertEqual(batch.decoder_input_ids.shape[1],1_0		)


    @require_torch
    def 						snake_case__					(				self			:	Optional[Any]		)->   Dict:





        '''simple docstring'''







        A__   				=       self.tokenizer._build_translation_inputs(
            'A test',return_tensors='pt',src_lang='eng_Latn',tgt_lang='fra_Latn'		)

        self.assertEqual(
            nested_simplify(lowercase_		),{
                # A, test, EOS, en_XX
                'input_ids': [[2_5_6_0_4_7, 7_0, 7_3_5_6, 2]],
                'attention_mask': [[1, 1, 1, 1]],
                # ar_AR
                'forced_bos_token_id': 2_5_6_0_5_7,
            },)


    @require_torch
    def 						snake_case__					(				self			:	Tuple		)->   Dict:





        '''simple docstring'''







        A__   				=       True
        A__   				=       self.tokenizer(
            'UN Chief says there is no military solution in Syria',src_lang='eng_Latn',tgt_lang='fra_Latn'		)
        self.assertEqual(
            inputs.input_ids,[1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2, 2_5_6_0_4_7]		)

        A__   				=       False
        A__   				=       self.tokenizer(
            'UN Chief says there is no military solution in Syria',src_lang='eng_Latn',tgt_lang='fra_Latn'		)
        self.assertEqual(
            inputs.input_ids,[2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2]		)




# XXX: we want transformers master here - in the absense of conftest manipulating sys.path:
# hack it in for now:
import sys
from pathlib import Path


lowercase_			=  Path(__file__).resolve().parents[3] / "src"
sys.path.insert(1, str(git_repo_path))

import dataclasses  # noqa
import io  # noqa
import itertools  # noqa
import json  # noqa
import os  # noqa
import unittest  # noqa
from copy import deepcopy  # noqa

from parameterized import parameterized  # noqa
from transformers import TrainingArguments, is_torch_available  # noqa
from transformers.deepspeed import is_deepspeed_available  # noqa
from transformers.file_utils import WEIGHTS_NAME  # noqa
from transformers.testing_utils import (  # noqa
    CaptureLogger,
    ExtendSysPath,
    TestCasePlus,
    execute_subprocess_async,
    get_gpu_count,
    mockenv_context,
    require_deepspeed,
    require_torch_gpu,
    require_torch_multi_gpu,
    slow,
)
from transformers.trainer_utils import set_seed  # noqa


set_seed(42)

lowercase_			=  {"base": "patrickvonplaten/wav2vec2_tiny_random", "robust": "patrickvonplaten/wav2vec2_tiny_random_robust"}

lowercase_			=  "zero2"
lowercase_			=  "zero3"
lowercase_			=  [ZEROa, ZEROa]
def 						_snake_case(   SCREAMING_SNAKE_CASE__      :     Optional[int]   ,      SCREAMING_SNAKE_CASE__      :     Tuple   ,      SCREAMING_SNAKE_CASE__      :     List[Any]				)							->				Dict:





    '''simple docstring'''






    A__   				=       parameterized.to_safe_name('_'.join(str(SCREAMING_SNAKE_CASE__				) for x in param.args				)				)
    return f'{func.__name__}_{param_based_name}'


# Cartesian-product of zero stages with models to test
lowercase_			=  list(itertools.product(stages, models.keys()))


@slow
@require_deepspeed
@require_torch_gpu
class 			A						(							_UpperCAmelCase			):







    """simple docstring"""





    @parameterized.expand(lowercase_,name_func=lowercase_		)
    def 						snake_case__					(				self			:	int,lowercase_			:	str,lowercase_			:	Any		)->   Optional[int]:





        '''simple docstring'''







        self.run_and_check(
            stage=lowercase_,model=lowercase_,distributed=lowercase_,fpaa=lowercase_,)


    @require_torch_multi_gpu
    @parameterized.expand(lowercase_,name_func=lowercase_		)
    def 						snake_case__					(				self			:	Union[str, Any],lowercase_			:	Optional[Any],lowercase_			:	List[Any]		)->   int:





        '''simple docstring'''







        self.run_and_check(
            stage=lowercase_,model=lowercase_,distributed=lowercase_,fpaa=lowercase_,)


    @parameterized.expand(lowercase_,name_func=lowercase_		)
    def 						snake_case__					(				self			:	List[str],lowercase_			:	List[str],lowercase_			:	List[Any]		)->   Any:





        '''simple docstring'''







        self.run_and_check(
            stage=lowercase_,model=lowercase_,distributed=lowercase_,fpaa=lowercase_,)


    @require_torch_multi_gpu
    @parameterized.expand(lowercase_,name_func=lowercase_		)
    def 						snake_case__					(				self			:	Dict,lowercase_			:	Optional[Any],lowercase_			:	List[Any]		)->   Optional[int]:





        '''simple docstring'''







        self.run_and_check(
            stage=lowercase_,model=lowercase_,distributed=lowercase_,fpaa=lowercase_,)


    def 						snake_case__					(				self			:	Tuple,lowercase_			:	Any		)->   Union[str, Any]:





        '''simple docstring'''







        pass


    def 						snake_case__					(				self			:	int,lowercase_			:	str,lowercase_			:	str,lowercase_			:	int = 1_0,lowercase_			:	bool = True,lowercase_			:	bool = True,lowercase_			:	bool = True,)->   Union[str, Any]:





        '''simple docstring'''







        A__   				=       models[model]

        A__   				=       self.run_trainer(
            stage=lowercase_,model_name=lowercase_,eval_steps=lowercase_,num_train_epochs=1,distributed=lowercase_,fpaa=lowercase_,)

        self.do_checks(lowercase_		)

        return output_dir


    def 						snake_case__					(				self			:	Union[str, Any],lowercase_			:	str,lowercase_			:	str,lowercase_			:	int = 1_0,lowercase_			:	int = 1,lowercase_			:	bool = True,lowercase_			:	bool = True,)->   Any:





        '''simple docstring'''







        A__   				=       self.get_auto_remove_tmp_dir('./xxx',after=lowercase_		)
        A__   				=       F'\n            --model_name_or_path {model_name}\n            --dataset_name hf-internal-testing/librispeech_asr_dummy\n            --dataset_config_name clean\n            --train_split_name validation\n            --validation_split_name validation\n            --output_dir {output_dir}\n            --num_train_epochs {str(lowercase_		)}\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 2\n            --evaluation_strategy steps\n            --learning_rate 5e-4\n            --warmup_steps 8\n            --orthography timit\n            --preprocessing_num_workers 1\n            --group_by_length\n            --freeze_feature_extractor\n            --report_to none\n            --save_steps 0\n            --eval_steps {eval_steps}\n            --report_to none\n        '.split()

        if fpaa:
            args.extend(['--fp16']		)

        # currently ds_config_wav2vec2_zero.json requires "zero_optimization.find_unused_parameters": true,
        # hence the separate config files
        A__   				=       F'--deepspeed {self.test_file_dir_str}/ds_config_wav2vec2_{stage}.json'.split()
        A__   				=       [F'{self.examples_dir_str}/research_projects/wav2vec2/run_asr.py']
        A__   				=       self.get_launcher(lowercase_		)

        A__   				=       launcher + script + args + ds_args
        # keep for quick debug
        # print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die
        execute_subprocess_async(lowercase_,env=self.get_env()		)

        return output_dir


    def 						snake_case__					(				self			:	Any,lowercase_			:	int=False		)->   Tuple:





        '''simple docstring'''







        A__   				=       min(2,get_gpu_count()		) if distributed else 1
        return F'deepspeed --num_nodes 1 --num_gpus {num_gpus}'.split()

