


import inspect
import json
import os
import tempfile
import unittest

from transformers.models.speech_to_text_a import SpeechaTextaTokenizer
from transformers.models.speech_to_text_a.tokenization_speech_to_text_a import VOCAB_FILES_NAMES

from ...test_tokenization_common import TokenizerTesterMixin







class lowerCAmelCase_						( lowerCamelCase__					,						unittest.TestCase       ):

 '''simple docstring'''

 __snake_case												=  SpeechaTextaTokenizer
 __snake_case												=  False



 def 						UpperCamelCase__     (	self					):
       super().setUp()

       snake_case_       =      '''<s> <pad> </s> <unk> here@@ a couple of@@ words for the he@@ re@@ vocab'''.split(''' '''					)
       snake_case_       =      ['''he re</w> 123''', '''here a 1456''']
       snake_case_       =      dict(zip(_UpperCAmelCase		,      range(len(_UpperCAmelCase					)					)					)					)

       snake_case_       =      {'''pad_token''': '''<pad>''', '''unk_token''': '''<unk>''', '''bos_token''': '''<s>''', '''eos_token''': '''</s>'''}

       snake_case_       =      tempfile.mkdtemp()
       snake_case_       =      os.path.join(self.tmpdirname		,      VOCAB_FILES_NAMES['''vocab_file''']					)
       snake_case_       =      os.path.join(self.tmpdirname		,      VOCAB_FILES_NAMES['''merges_file''']					)

       with open(self.vocab_file		,      '''w'''		,      encoding='''utf-8'''					) as fp:
             fp.write(json.dumps(_UpperCAmelCase					) + '''\n'''					)

       with open(self.merges_file		,      '''w'''					) as fp:
             fp.write('''\n'''.join(_UpperCAmelCase					)					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      list(self.get_tokenizer().get_vocab().keys()					)

       self.assertEqual(vocab_keys[0]		,      '''<s>'''					)
       self.assertEqual(vocab_keys[1]		,      '''<pad>'''					)
       self.assertEqual(vocab_keys[-1]		,      '''vocab'''					)
       self.assertEqual(len(_UpperCAmelCase					)		,      14					)



 def 						UpperCamelCase__     (	self					):
       self.assertEqual(self.get_tokenizer().vocab_size		,      14					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      SpeechaTextaTokenizer.from_pretrained(self.tmpdirname					)

       # make sure @@ is correctly concatenated
       snake_case_       =      [4, 6, 8, 7, 10]  # ["here@@", "couple", "words", "of@@", "the"]
       snake_case_       =      tokenizer.decode(_UpperCAmelCase					)

       self.assertTrue(output_string == '''herecouple words ofthe'''					)



 def 						UpperCamelCase__     (	self					):
       snake_case_       =      SpeechaTextaTokenizer.from_pretrained(self.tmpdirname					)

       with tempfile.TemporaryDirectory() as tmp_dirname:
             tokenizer.save_pretrained(_UpperCAmelCase					)
             os.remove(os.path.join(_UpperCAmelCase		,      '''merges.txt'''					)					)

             # load tokenizer without merges file should not throw an error
             snake_case_       =      SpeechaTextaTokenizer.from_pretrained(_UpperCAmelCase					)

       with tempfile.TemporaryDirectory() as tmp_dirname:
             # save tokenizer and load again
             tokenizer.save_pretrained(_UpperCAmelCase					)
             snake_case_       =      SpeechaTextaTokenizer.from_pretrained(_UpperCAmelCase					)

       self.assertIsNotNone(_UpperCAmelCase					)





 def 						UpperCamelCase__     (	self					):
       if not self.test_slow_tokenizer:
             return

       snake_case_       =      inspect.signature(self.tokenizer_class.__init__					)
       snake_case_       =      self.get_tokenizer()

       for parameter_name, parameter in signature.parameters.items():
             if parameter.default != inspect.Parameter.empty and parameter_name != "merges_file":
                   self.assertIn(_UpperCAmelCase		,      tokenizer.init_kwargs					)



import argparse
import os


UpperCAmelCase			=    {
    """pytorch""": {
        """1.13""": {
            """torch""": """1.13.1""",
            """torchvision""": """0.14.1""",
            """torchaudio""": """0.13.1""",
            """python""": 3.9,
            """cuda""": """cu116""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1"""
                """ --extra-index-url https://download.pytorch.org/whl/cu116"""
            ),
            """base_image""": """nvidia/cuda:11.6.2-cudnn8-devel-ubuntu20.04""",
        },
        """1.12""": {
            """torch""": """1.12.1""",
            """torchvision""": """0.13.1""",
            """torchaudio""": """0.12.1""",
            """python""": 3.9,
            """cuda""": """cu113""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.12.1 torchvision==0.13.1 torchaudio==0.12.1"""
                """ --extra-index-url https://download.pytorch.org/whl/cu113"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """1.11""": {
            """torch""": """1.11.0""",
            """torchvision""": """0.12.0""",
            """torchaudio""": """0.11.0""",
            """python""": 3.9,
            """cuda""": """cu113""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.11.0 torchvision==0.12.0 torchaudio==0.11.0"""
                """ --extra-index-url https://download.pytorch.org/whl/cu113"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """1.10""": {
            """torch""": """1.10.2""",
            """torchvision""": """0.11.3""",
            """torchaudio""": """0.10.2""",
            """python""": 3.9,
            """cuda""": """cu113""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.10.2 torchvision==0.11.3 torchaudio==0.10.2"""
                """ --extra-index-url https://download.pytorch.org/whl/cu113"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        # torchaudio < 0.10 has no CUDA-enabled binary distributions
        """1.9""": {
            """torch""": """1.9.1""",
            """torchvision""": """0.10.1""",
            """torchaudio""": """0.9.1""",
            """python""": 3.9,
            """cuda""": """cu111""",
            """install""": (
                """python3 -m pip install --no-cache-dir -U torch==1.9.1 torchvision==0.10.1 torchaudio==0.9.1"""
                """ --extra-index-url https://download.pytorch.org/whl/cu111"""
            ),
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
    },
    """tensorflow""": {
        """2.11""": {
            """tensorflow""": """2.11.1""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.11.1""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.10""": {
            """tensorflow""": """2.10.1""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.10.1""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.9""": {
            """tensorflow""": """2.9.3""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.9.3""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.8""": {
            """tensorflow""": """2.8.2""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.8.2""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.7""": {
            """tensorflow""": """2.7.3""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.7.3""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.6""": {
            """tensorflow""": """2.6.5""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.6.5""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
        """2.5""": {
            """tensorflow""": """2.5.3""",
            """install""": """python3 -m pip install --no-cache-dir -U tensorflow==2.5.3""",
            """base_image""": """nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04""",
        },
    },
}


if __name__ == "__main__":
   UpperCAmelCase			=    argparse.ArgumentParser("""Choose the framework and version to install""")
   parser.add_argument(
       """--framework""", help="""The framework to install. Should be `torch` or `tensorflow`""", type=str, required=True
   )
   parser.add_argument("""--version""", help="""The version of the framework to install.""", type=str, required=True)
   UpperCAmelCase			=    parser.parse_args()

   UpperCAmelCase			=    past_versions_testing[args.framework][args.version]

   os.system(f'''echo "export INSTALL_CMD=\'{info['install']}\'" >> ~/.profile''')
   print(f'''echo "export INSTALL_CMD=\'{info['install']}\'" >> ~/.profile''')

   UpperCAmelCase			=    """"""
   if args.framework == "pytorch":
      UpperCAmelCase			=    info["""cuda"""]
   os.system(f'''echo \"export CUDA=\'{cuda}\'\" >> ~/.profile''')
   print(f'''echo \"export CUDA=\'{cuda}\'\" >> ~/.profile''')