




import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
 from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


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

@require_torch
@require_torchaudio
@require_sentencepiece
class        _lowerCamelCase  (	unittest.TestCase      ):

      """simple docstring"""

      def 					snake_case		(   self    :       List[str] ):
          __UpperCamelCase     						=  tempfile.mkdtemp()

          __UpperCamelCase     						=  ['''<s>''', '''<pad>''', '''</s>''', '''<unk>''', '''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
          __UpperCamelCase     						=  dict(zip(snake_case       ,				range(len(snake_case ) ) ) )
          __UpperCamelCase     						=  Path(self.tmpdirname )
          save_json(snake_case       ,				save_dir / VOCAB_FILES_NAMES['''vocab_file'''] )
          if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
              copyfile(snake_case       ,				save_dir / VOCAB_FILES_NAMES['''spm_file'''] )

          __UpperCamelCase     						=  SpeechaTextTokenizer.from_pretrained(self.tmpdirname )
          tokenizer.save_pretrained(self.tmpdirname )

          __UpperCamelCase     						=  {
              '''feature_size''': 24,
              '''num_mel_bins''': 24,
              '''padding_value''': 0.0,
              '''sampling_rate''': 16000,
              '''return_attention_mask''': False,
              '''do_normalize''': True,
          }
          save_json(snake_case       ,				save_dir / FEATURE_EXTRACTOR_NAME )







      def 					snake_case		(   self    :       List[Any]       ,				**snake_case    :       Any ):
          return SpeechaTextTokenizer.from_pretrained(self.tmpdirname       ,				**snake_case )







      def 					snake_case		(   self    :       Any       ,				**snake_case    :       Tuple ):
          return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname       ,				**snake_case )







      def 					snake_case		(   self    :       Optional[int] ):
          shutil.rmtree(self.tmpdirname )







      def 					snake_case		(   self    :       Union[str, Any] ):
          __UpperCamelCase     						=  self.get_tokenizer()
          __UpperCamelCase     						=  self.get_feature_extractor()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          processor.save_pretrained(self.tmpdirname )
          __UpperCamelCase     						=  SpeechaTextProcessor.from_pretrained(self.tmpdirname )

          self.assertEqual(processor.tokenizer.get_vocab()       ,				tokenizer.get_vocab() )
          self.assertIsInstance(processor.tokenizer       ,				snake_case )

          self.assertEqual(processor.feature_extractor.to_json_string()       ,				feature_extractor.to_json_string() )
          self.assertIsInstance(processor.feature_extractor       ,				snake_case )







      def 					snake_case		(   self    :       Dict ):
          __UpperCamelCase     						=  SpeechaTextProcessor(
              tokenizer=self.get_tokenizer()       ,				feature_extractor=self.get_feature_extractor() )
          processor.save_pretrained(self.tmpdirname )

          __UpperCamelCase     						=  self.get_tokenizer(bos_token='''(BOS)'''       ,				eos_token='''(EOS)''' )
          __UpperCamelCase     						=  self.get_feature_extractor(do_normalize=snake_case       ,				padding_value=1.0 )

          __UpperCamelCase     						=  SpeechaTextProcessor.from_pretrained(
              self.tmpdirname       ,				bos_token='''(BOS)'''       ,				eos_token='''(EOS)'''       ,				do_normalize=snake_case       ,				padding_value=1.0 )

          self.assertEqual(processor.tokenizer.get_vocab()       ,				tokenizer_add_kwargs.get_vocab() )
          self.assertIsInstance(processor.tokenizer       ,				snake_case )

          self.assertEqual(processor.feature_extractor.to_json_string()       ,				feature_extractor_add_kwargs.to_json_string() )
          self.assertIsInstance(processor.feature_extractor       ,				snake_case )







      def 					snake_case		(   self    :       Any ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          __UpperCamelCase     						=  floats_list((3, 1000) )

          __UpperCamelCase     						=  feature_extractor(snake_case       ,				return_tensors='''np''' )
          __UpperCamelCase     						=  processor(snake_case       ,				return_tensors='''np''' )

          for key in input_feat_extract.keys():
              self.assertAlmostEqual(input_feat_extract[key].sum()       ,				input_processor[key].sum()       ,				delta=1E-2 )







      def 					snake_case		(   self    :       Optional[int] ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          __UpperCamelCase     						=  '''This is a test string'''

          __UpperCamelCase     						=  processor(text=snake_case )

          __UpperCamelCase     						=  tokenizer(snake_case )

          for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key]       ,				encoded_processor[key] )







      def 					snake_case		(   self    :       Tuple ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          __UpperCamelCase     						=  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          __UpperCamelCase     						=  processor.batch_decode(snake_case )
          __UpperCamelCase     						=  tokenizer.batch_decode(snake_case )

          self.assertListEqual(snake_case       ,				snake_case )







      def 					snake_case		(   self    :       List[str] ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          self.assertListEqual(
              processor.model_input_names       ,				feature_extractor.model_input_names       ,				msg='''`processor` and `feature_extractor` model input names do not match'''       ,				)










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''')