




import argparse
import os
import re


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_dummies.py
snake_case__ :						List[str]     =			'''src/transformers'''

# Matches is_xxx_available()
snake_case__ :						int     =			re.compile(R'''is\_([a-z_]*)_available()''')
# Matches from xxx import bla
snake_case__ :						Optional[Any]     =			re.compile(R'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
snake_case__ :						Optional[Any]     =			re.compile(R'''^\s+if\s+not\s+\(?is\_[a-z_]*\_available\(\)''')


snake_case__ :						int     =			'''
{0} = None
'''

snake_case__ :						Tuple     =			'''
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})
'''


snake_case__ :						int     =			'''
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
'''


def 						lowercase		(     _lowerCAmelCase      ):
  if _re_test_backend.search(_lowerCAmelCase      ) is None:
    return None
  UpperCAmelCase__    						=   [b[0] for b in _re_backend.findall(_lowerCAmelCase      )]
  backends.sort()
  return "_and_".join(_lowerCAmelCase      )


def 						lowercase		(     ):
  with open(os.path.join(_lowerCAmelCase   ,     """__init__.py"""      )   ,     """r"""   ,     encoding="""utf-8"""   ,     newline="""\n"""      ) as f:
    UpperCAmelCase__    						=   f.readlines()

  # Get to the point we do the actual imports for type checking
  UpperCAmelCase__    						=   0
  while not lines[line_index].startswith("""if TYPE_CHECKING"""      ):
    line_index += 1

  UpperCAmelCase__    						=   {}
  # Go through the end of the file
  while line_index < len(_lowerCAmelCase      ):
    # If the line is an if is_backend_available, we grab all objects associated.
    UpperCAmelCase__    						=   find_backend(lines[line_index]      )
    if backend is not None:
      while not lines[line_index].startswith("""    else:"""      ):
        line_index += 1
      line_index += 1

      UpperCAmelCase__    						=   []
      # Until we unindent, add backend objects to the list
      while len(lines[line_index]      ) <= 1 or lines[line_index].startswith(""" """ * 8      ):
        UpperCAmelCase__    						=   lines[line_index]
        UpperCAmelCase__    						=   _re_single_line_import.search(_lowerCAmelCase      )
        if single_line_import_search is not None:
          objects.extend(single_line_import_search.groups()[0].split(""", """      )      )
        elif line.startswith(""" """ * 12      ):
          objects.append(line[12:-2]      )
        line_index += 1

      UpperCAmelCase__    						=   objects
    else:
      line_index += 1

  return backend_specific_objects


def 						lowercase		(     _lowerCAmelCase   ,     _lowerCAmelCase      ):
  if name.isupper():
    return DUMMY_CONSTANT.format(_lowerCAmelCase      )
  elif name.islower():
    return DUMMY_FUNCTION.format(_lowerCAmelCase   ,     _lowerCAmelCase      )
  else:
    return DUMMY_CLASS.format(_lowerCAmelCase   ,     _lowerCAmelCase      )


def 						lowercase		(     _lowerCAmelCase=None      ):
  if backend_specific_objects is None:
    UpperCAmelCase__    						=   read_init()
  # For special correspondence backend to module name as used in the function requires_modulename
  UpperCAmelCase__    						=   {}

  for backend, objects in backend_specific_objects.items():
    UpperCAmelCase__    						=   """[""" + """, """.join(F'''"{b}"''' for b in backend.split("""_and_"""      )      ) + """]"""
    UpperCAmelCase__    						=   """# This file is autogenerated by the command `make fix-copies`, do not edit.\n"""
    dummy_file += "from ..utils import DummyObject, requires_backends\n\n"
    dummy_file += "\n".join([create_dummy_object(_lowerCAmelCase   ,     _lowerCAmelCase      ) for o in objects]      )
    UpperCAmelCase__    						=   dummy_file

  return dummy_files


def 						lowercase		(     _lowerCAmelCase=False      ):
  UpperCAmelCase__    						=   create_dummy_files()
  # For special correspondence backend to shortcut as used in utils/dummy_xxx_objects.py
  UpperCAmelCase__    						=   {"""torch""": """pt"""}

  # Locate actual dummy modules and read their content.
  UpperCAmelCase__    						=   os.path.join(_lowerCAmelCase   ,     """utils"""      )
  UpperCAmelCase__    						=   {
      backend: os.path.join(_lowerCAmelCase   ,     F'''dummy_{short_names.get(_lowerCAmelCase   ,     _lowerCAmelCase      )}_objects.py'''      )
      for backend in dummy_files.keys()
  }

  UpperCAmelCase__    						=   {}
  for backend, file_path in dummy_file_paths.items():
    if os.path.isfile(_lowerCAmelCase      ):
      with open(_lowerCAmelCase   ,     """r"""   ,     encoding="""utf-8"""   ,     newline="""\n"""      ) as f:
        UpperCAmelCase__    						=   f.read()
    else:
      UpperCAmelCase__    						=   """"""

  for backend in dummy_files.keys():
    if dummy_files[backend] != actual_dummies[backend]:
      if overwrite:
        print(
            F'''Updating transformers.utils.dummy_{short_names.get(_lowerCAmelCase   ,     _lowerCAmelCase      )}_objects.py as the main '''
            """__init__ has new objects."""      )
        with open(dummy_file_paths[backend]   ,     """w"""   ,     encoding="""utf-8"""   ,     newline="""\n"""      ) as f:
          f.write(dummy_files[backend]      )
      else:
        raise ValueError(
            """The main __init__ has objects that are not present in """
            F'''transformers.utils.dummy_{short_names.get(_lowerCAmelCase   ,     _lowerCAmelCase      )}_objects.py. Run `make fix-copies` '''
            """to fix this."""      )


if __name__ == "__main__":
    snake_case__ :						List[Any]     =			argparse.ArgumentParser()
    parser.add_argument('''--fix_and_overwrite''', action='''store_true''', help='''Whether to fix inconsistencies.''')
    snake_case__ :						str     =			parser.parse_args()

    check_dummies(args.fix_and_overwrite)










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


snake_case__ :						Union[str, Any]     =			get_tests_dir('''fixtures/test_sentencepiece.model''')





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


   '''simple docstring'''







   def 	UpperCAmelCase       (					self     :	str			)					->str:
     '''simple docstring'''







     UpperCAmelCase__    						=   tempfile.mkdtemp()

     UpperCAmelCase__    						=   ["""<s>""", """<pad>""", """</s>""", """<unk>""", """▁This""", """▁is""", """▁a""", """▁t""", """est"""]
     UpperCAmelCase__    						=   dict(zip(lowerCamelCase_						,    range(len(lowerCamelCase_			)			)			)			)
     UpperCAmelCase__    						=   Path(self.tmpdirname			)
     save_json(lowerCamelCase_						,    save_dir / VOCAB_FILES_NAMES["""vocab_file"""]			)
     if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
       copyfile(lowerCamelCase_						,    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""": 1_6000,
         """return_attention_mask""": False,
         """do_normalize""": True,
     }
     save_json(lowerCamelCase_						,    save_dir / FEATURE_EXTRACTOR_NAME			)




   def 	UpperCAmelCase       (					self     :	Union[str, Any]						,    **lowerCamelCase_     :	Tuple			)					->Any:
     '''simple docstring'''







     return SpeechaTextTokenizer.from_pretrained(self.tmpdirname						,    **lowerCamelCase_			)




   def 	UpperCAmelCase       (					self     :	Dict						,    **lowerCamelCase_     :	str			)					->Optional[Any]:
     '''simple docstring'''







     return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname						,    **lowerCamelCase_			)




   def 	UpperCAmelCase       (					self     :	List[str]			)					->Dict:
     '''simple docstring'''







     shutil.rmtree(self.tmpdirname			)




   def 	UpperCAmelCase       (					self     :	str			)					->Tuple:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_tokenizer()
     UpperCAmelCase__    						=   self.get_feature_extractor()

     UpperCAmelCase__    						=   SpeechaTextProcessor(tokenizer=lowerCamelCase_						,    feature_extractor=lowerCamelCase_			)

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

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

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




   def 	UpperCAmelCase       (					self     :	List[str]			)					->Tuple:
     '''simple docstring'''







     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=lowerCamelCase_						,    padding_value=1.0			)

     UpperCAmelCase__    						=   SpeechaTextProcessor.from_pretrained(
         self.tmpdirname						,    bos_token="""(BOS)"""						,    eos_token="""(EOS)"""						,    do_normalize=lowerCamelCase_						,    padding_value=1.0			)

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

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




   def 	UpperCAmelCase       (					self     :	Union[str, Any]			)					->Tuple:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_feature_extractor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   SpeechaTextProcessor(tokenizer=lowerCamelCase_						,    feature_extractor=lowerCamelCase_			)

     UpperCAmelCase__    						=   floats_list((3, 1000)			)

     UpperCAmelCase__    						=   feature_extractor(lowerCamelCase_						,    return_tensors="""np"""			)
     UpperCAmelCase__    						=   processor(lowerCamelCase_						,    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 	UpperCAmelCase       (					self     :	str			)					->Union[str, Any]:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_feature_extractor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   SpeechaTextProcessor(tokenizer=lowerCamelCase_						,    feature_extractor=lowerCamelCase_			)

     UpperCAmelCase__    						=   """This is a test string"""

     UpperCAmelCase__    						=   processor(text=lowerCamelCase_			)

     UpperCAmelCase__    						=   tokenizer(lowerCamelCase_			)

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




   def 	UpperCAmelCase       (					self     :	Optional[Any]			)					->Tuple:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_feature_extractor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   SpeechaTextProcessor(tokenizer=lowerCamelCase_						,    feature_extractor=lowerCamelCase_			)

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

     UpperCAmelCase__    						=   processor.batch_decode(lowerCamelCase_			)
     UpperCAmelCase__    						=   tokenizer.batch_decode(lowerCamelCase_			)

     self.assertListEqual(lowerCamelCase_						,    lowerCamelCase_			)







   def 	UpperCAmelCase       (					self     :	Dict			)					->Tuple:
     '''simple docstring'''







     UpperCAmelCase__    						=   self.get_feature_extractor()
     UpperCAmelCase__    						=   self.get_tokenizer()

     UpperCAmelCase__    						=   SpeechaTextProcessor(tokenizer=lowerCamelCase_						,    feature_extractor=lowerCamelCase_			)

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




