





'''simple docstring'''

import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
    from huggingface_hub import snapshot_download
    from pyctcdecode import BeamSearchDecoderCTC

    from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
    from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
    from transformers import WavaVecaForCTC







@require_pyctcdecode
class __a (   unittest.TestCase			):





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       """| <pad> <unk> <s> </s> a b c d e f g h i j k""".split()
      __SCREAMING_SNAKE_CASE      							=       dict(zip(lowerCamelCase				,range(len(lowerCamelCase    )    )    )    )

      __SCREAMING_SNAKE_CASE      							=       {
          """unk_token""": """<unk>""",
          """bos_token""": """<s>""",
          """eos_token""": """</s>""",
      }
      __SCREAMING_SNAKE_CASE      							=       {
          """feature_size""": 1,
          """padding_value""": 0.0,
          """sampling_rate""": 1_6000,
          """return_attention_mask""": False,
          """do_normalize""": True,
      }

      __SCREAMING_SNAKE_CASE      							=       tempfile.mkdtemp()
      __SCREAMING_SNAKE_CASE      							=       os.path.join(self.tmpdirname				,VOCAB_FILES_NAMES["""vocab_file"""]    )
      __SCREAMING_SNAKE_CASE      							=       os.path.join(self.tmpdirname				,lowerCamelCase    )
      with open(self.vocab_file				,"""w"""				,encoding="""utf-8"""    ) as fp:
         fp.write(json.dumps(lowerCamelCase    ) + """\n"""    )

      with open(self.feature_extraction_file				,"""w"""				,encoding="""utf-8"""    ) as fp:
         fp.write(json.dumps(lowerCamelCase    ) + """\n"""    )

      # load decoder from hub
      __SCREAMING_SNAKE_CASE      							=       """hf-internal-testing/ngram-beam-search-decoder"""





   def      UpperCAmelCase__     (					self				:			List[Any]				,**lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.add_kwargs_tokens_map.copy()
      kwargs.update(lowerCamelCase    )
      return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname				,**lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Union[str, Any]				,**lowerCamelCase				:			List[str]    ):

      '''simple docstring'''

      return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname				,**lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			int				,**lowerCamelCase				:			Optional[Any]    ):

      '''simple docstring'''

      return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name				,**lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      shutil.rmtree(self.tmpdirname    )





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

      processor.save_pretrained(self.tmpdirname    )
      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname    )

      # tokenizer
      self.assertEqual(processor.tokenizer.get_vocab()				,tokenizer.get_vocab()    )
      self.assertIsInstance(processor.tokenizer				,lowerCamelCase    )

      # feature extractor
      self.assertEqual(processor.feature_extractor.to_json_string()				,feature_extractor.to_json_string()    )
      self.assertIsInstance(processor.feature_extractor				,lowerCamelCase    )

      # decoder
      self.assertEqual(processor.decoder._alphabet.labels				,decoder._alphabet.labels    )
      self.assertEqual(
          processor.decoder.model_container[decoder._model_key]._unigram_set				,decoder.model_container[decoder._model_key]._unigram_set				,)
      self.assertIsInstance(processor.decoder				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(
          tokenizer=self.get_tokenizer()				,feature_extractor=self.get_feature_extractor()				,decoder=self.get_decoder()    )
      processor.save_pretrained(self.tmpdirname    )

      # make sure that error is thrown when decoder alphabet doesn't match
      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM.from_pretrained(
          self.tmpdirname				,alpha=5.0				,beta=3.0				,score_boundary=-7.0				,unk_score_offset=3    )

      # decoder
      self.assertEqual(processor.language_model.alpha				,5.0    )
      self.assertEqual(processor.language_model.beta				,3.0    )
      self.assertEqual(processor.language_model.score_boundary				,-7.0    )
      self.assertEqual(processor.language_model.unk_score_offset				,3    )





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      # add token to trigger raise
      tokenizer.add_tokens(["""xx"""]    )
      with self.assertRaisesRegex(lowerCamelCase				,"""include"""    ):
         WavaVecaProcessorWithLM(
             tokenizer=lowerCamelCase				,feature_extractor=self.get_feature_extractor()				,decoder=self.get_decoder()    )





   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       floats_list((3, 1000)    )

      __SCREAMING_SNAKE_CASE      							=       feature_extractor(lowerCamelCase				,return_tensors="""np"""    )
      __SCREAMING_SNAKE_CASE      							=       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				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       """This is a test string"""

      __SCREAMING_SNAKE_CASE      							=       processor(text=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       tokenizer(lowerCamelCase    )

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





   def      UpperCAmelCase__     (					self				:			List[Any]				,lowerCamelCase				:			List[Any]=(2, 10, 16)				,lowerCamelCase				:			Tuple=77    ):

      '''simple docstring'''

      np.random.seed(lowerCamelCase    )
      return np.random.rand(*lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       self._get_dummy_logits(shape=(10, 16)				,seed=13    )

      __SCREAMING_SNAKE_CASE      							=       processor.decode(lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       decoder.decode_beams(lowerCamelCase    )[0]

      self.assertEqual(decoded_decoder[0]				,decoded_processor.text    )
      self.assertEqual("""</s> <s> </s>"""				,decoded_processor.text    )
      self.assertEqual(decoded_decoder[-2]				,decoded_processor.logit_score    )
      self.assertEqual(decoded_decoder[-1]				,decoded_processor.lm_score    )





   @parameterized.expand([[None], ["""fork"""], ["""spawn"""]]    )
   def      UpperCAmelCase__     (					self				:			Any				,lowerCamelCase				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       self._get_dummy_logits()

      # note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
      #       otherwise, the LM won't be available to the pool's sub-processes.
      # manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
      if pool_context is None:
         __SCREAMING_SNAKE_CASE      							=       processor.batch_decode(lowerCamelCase    )
      else:
         with get_context(lowerCamelCase    ).Pool() as pool:
            __SCREAMING_SNAKE_CASE      							=       processor.batch_decode(lowerCamelCase				,lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       list(lowerCamelCase    )

      with get_context("""fork"""    ).Pool() as p:
         __SCREAMING_SNAKE_CASE      							=       decoder.decode_beams_batch(lowerCamelCase				,lowerCamelCase    )

      __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE							,     __SCREAMING_SNAKE_CASE      							=       [], [], []
      for beams in decoded_beams:
         texts_decoder.append(beams[0][0]    )
         logit_scores_decoder.append(beams[0][-2]    )
         lm_scores_decoder.append(beams[0][-1]    )

      self.assertListEqual(lowerCamelCase				,decoded_processor.text    )
      self.assertListEqual(["""<s> <s> </s>""", """<s> <s> <s>"""]				,decoded_processor.text    )
      self.assertListEqual(lowerCamelCase				,decoded_processor.logit_score    )
      self.assertListEqual(lowerCamelCase				,decoded_processor.lm_score    )





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       self._get_dummy_logits()

      __SCREAMING_SNAKE_CASE      							=       15
      __SCREAMING_SNAKE_CASE      							=       -20.0
      __SCREAMING_SNAKE_CASE      							=       -4.0

      __SCREAMING_SNAKE_CASE      							=       processor.batch_decode(
          lowerCamelCase				,beam_width=lowerCamelCase				,beam_prune_logp=lowerCamelCase				,token_min_logp=lowerCamelCase				,)
      __SCREAMING_SNAKE_CASE      							=       decoded_processor_out.text

      __SCREAMING_SNAKE_CASE      							=       list(lowerCamelCase    )

      with get_context("""fork"""    ).Pool() as pool:
         __SCREAMING_SNAKE_CASE      							=       decoder.decode_beams_batch(
             lowerCamelCase				,lowerCamelCase				,beam_width=lowerCamelCase				,beam_prune_logp=lowerCamelCase				,token_min_logp=lowerCamelCase				,)

      __SCREAMING_SNAKE_CASE      							=       [d[0][0] for d in decoded_decoder_out]
      __SCREAMING_SNAKE_CASE      							=       [d[0][2] for d in decoded_decoder_out]
      __SCREAMING_SNAKE_CASE      							=       [d[0][3] for d in decoded_decoder_out]

      self.assertListEqual(lowerCamelCase				,lowerCamelCase    )
      self.assertListEqual(["""</s> <s> <s>""", """<s> <s> <s>"""]				,lowerCamelCase    )

      self.assertTrue(np.array_equal(lowerCamelCase				,decoded_processor_out.logit_score    )    )
      self.assertTrue(np.allclose([-20.054, -18.447]				,lowerCamelCase				,atol=1E-3    )    )

      self.assertTrue(np.array_equal(lowerCamelCase				,decoded_processor_out.lm_score    )    )
      self.assertTrue(np.allclose([-15.554, -13.9_474]				,lowerCamelCase				,atol=1E-3    )    )





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       self._get_dummy_logits()

      __SCREAMING_SNAKE_CASE      							=       2.0
      __SCREAMING_SNAKE_CASE      							=       5.0
      __SCREAMING_SNAKE_CASE      							=       -20.0
      __SCREAMING_SNAKE_CASE      							=       True

      __SCREAMING_SNAKE_CASE      							=       processor.batch_decode(
          lowerCamelCase				,alpha=lowerCamelCase				,beta=lowerCamelCase				,unk_score_offset=lowerCamelCase				,lm_score_boundary=lowerCamelCase				,)
      __SCREAMING_SNAKE_CASE      							=       decoded_processor_out.text

      __SCREAMING_SNAKE_CASE      							=       list(lowerCamelCase    )
      decoder.reset_params(
          alpha=lowerCamelCase				,beta=lowerCamelCase				,unk_score_offset=lowerCamelCase				,lm_score_boundary=lowerCamelCase				,)

      with get_context("""fork"""    ).Pool() as pool:
         __SCREAMING_SNAKE_CASE      							=       decoder.decode_beams_batch(
             lowerCamelCase				,lowerCamelCase				,)

      __SCREAMING_SNAKE_CASE      							=       [d[0][0] for d in decoded_decoder_out]

      self.assertListEqual(lowerCamelCase				,lowerCamelCase    )
      self.assertListEqual(["""<s> </s> <s> </s> </s>""", """</s> </s> <s> </s> </s>"""]				,lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       processor.decoder.model_container[processor.decoder._model_key]
      self.assertEqual(lm_model.alpha				,2.0    )
      self.assertEqual(lm_model.beta				,5.0    )
      self.assertEqual(lm_model.unk_score_offset				,-20.0    )
      self.assertEqual(lm_model.score_boundary				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			List[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""    )

      __SCREAMING_SNAKE_CASE      							=       processor.decoder.model_container[processor.decoder._model_key]
      __SCREAMING_SNAKE_CASE      							=       Path(language_model._kenlm_model.path.decode("""utf-8"""    )    ).parent.parent.absolute()

      __SCREAMING_SNAKE_CASE      							=       os.listdir(lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       ["""alphabet.json""", """language_model"""]

      downloaded_decoder_files.sort()
      expected_decoder_files.sort()

      # test that only decoder relevant files from
      # https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
      # are downloaded and none of the rest (e.g. README.md, ...)
      self.assertListEqual(lowerCamelCase				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       snapshot_download("""hf-internal-testing/processor_with_lm"""    )

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM.from_pretrained(lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       processor.decoder.model_container[processor.decoder._model_key]
      __SCREAMING_SNAKE_CASE      							=       Path(language_model._kenlm_model.path.decode("""utf-8"""    )    ).parent.parent.absolute()

      __SCREAMING_SNAKE_CASE      							=       os.listdir(lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       os.listdir(lowerCamelCase    )

      local_decoder_files.sort()
      expected_decoder_files.sort()

      # test that both decoder form hub and local files in cache are the same
      self.assertListEqual(lowerCamelCase				,lowerCamelCase    )





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""    )
      __SCREAMING_SNAKE_CASE      							=       AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm"""    )

      __SCREAMING_SNAKE_CASE      							=       floats_list((3, 1000)    )

      __SCREAMING_SNAKE_CASE      							=       processor_wavaveca(lowerCamelCase				,return_tensors="""np"""    )
      __SCREAMING_SNAKE_CASE      							=       processor_auto(lowerCamelCase				,return_tensors="""np"""    )

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

      __SCREAMING_SNAKE_CASE      							=       self._get_dummy_logits()

      __SCREAMING_SNAKE_CASE      							=       processor_wavaveca.batch_decode(lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       processor_auto.batch_decode(lowerCamelCase    )

      self.assertListEqual(decoded_wavaveca.text				,decoded_auto.text    )





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_feature_extractor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()
      __SCREAMING_SNAKE_CASE      							=       self.get_decoder()

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM(tokenizer=lowerCamelCase				,feature_extractor=lowerCamelCase				,decoder=lowerCamelCase    )

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





   @staticmethod
   def      UpperCAmelCase__     (					lowerCamelCase				:			Union[str, Any]				,lowerCamelCase				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       [d[key] for d in offsets]
      return retrieved_list





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""    )
      __SCREAMING_SNAKE_CASE      							=       self._get_dummy_logits()[0]

      __SCREAMING_SNAKE_CASE      							=       processor.decode(lowerCamelCase				,output_word_offsets=lowerCamelCase    )
      # check Wav2Vec2CTCTokenizerOutput keys for word
      self.assertEqual(len(outputs.keys()    )				,4    )
      self.assertTrue("""text""" in outputs    )
      self.assertTrue("""word_offsets""" in outputs    )
      self.assertTrue(isinstance(lowerCamelCase				,lowerCamelCase    )    )

      self.assertEqual(""" """.join(self.get_from_offsets(outputs["""word_offsets"""]				,"""word"""    )    )				,outputs.text    )
      self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]				,"""word"""    )				,["""<s>""", """<s>""", """</s>"""]    )
      self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]				,"""start_offset"""    )				,[0, 2, 4]    )
      self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""]				,"""end_offset"""    )				,[1, 3, 5]    )





   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""    )
      __SCREAMING_SNAKE_CASE      							=       self._get_dummy_logits()

      __SCREAMING_SNAKE_CASE      							=       processor.batch_decode(lowerCamelCase				,output_word_offsets=lowerCamelCase    )

      # check Wav2Vec2CTCTokenizerOutput keys for word
      self.assertEqual(len(outputs.keys()    )				,4    )
      self.assertTrue("""text""" in outputs    )
      self.assertTrue("""word_offsets""" in outputs    )
      self.assertTrue(isinstance(lowerCamelCase				,lowerCamelCase    )    )

      self.assertListEqual(
          [""" """.join(self.get_from_offsets(lowerCamelCase				,"""word"""    )    ) for o in outputs["""word_offsets"""]]				,outputs.text    )
      self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]				,"""word"""    )				,["""<s>""", """<s>""", """</s>"""]    )
      self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]				,"""start_offset"""    )				,[0, 2, 4]    )
      self.assertListEqual(self.get_from_offsets(outputs["""word_offsets"""][0]				,"""end_offset"""    )				,[1, 3, 5]    )





   @slow
   @require_torch
   @require_torchaudio
   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      import torch

      __SCREAMING_SNAKE_CASE      							=       load_dataset("""common_voice"""				,"""en"""				,split="""train"""				,streaming=lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       ds.cast_column("""audio"""				,datasets.Audio(sampling_rate=1_6000    )    )
      __SCREAMING_SNAKE_CASE      							=       iter(lowerCamelCase    )
      __SCREAMING_SNAKE_CASE      							=       next(lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm"""    )
      __SCREAMING_SNAKE_CASE      							=       WavaVecaForCTC.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm"""    )

      # compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
      __SCREAMING_SNAKE_CASE      							=       processor(sample["""audio"""]["""array"""]				,return_tensors="""pt"""    ).input_values

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE      							=       model(lowerCamelCase    ).logits.cpu().numpy()

      __SCREAMING_SNAKE_CASE      							=       processor.decode(logits[0]				,output_word_offsets=lowerCamelCase    )

      __SCREAMING_SNAKE_CASE      							=       model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
      __SCREAMING_SNAKE_CASE      							=       [
          {
              """start_time""": d["""start_offset"""] * time_offset,
              """end_time""": d["""end_offset"""] * time_offset,
              """word""": d["""word"""],
          }
          for d in output["""word_offsets"""]
      ]

      __SCREAMING_SNAKE_CASE      							=       """WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL"""

      # output words
      self.assertEqual(""" """.join(self.get_from_offsets(lowerCamelCase				,"""word"""    )    )				,lowerCamelCase    )
      self.assertEqual(""" """.join(self.get_from_offsets(lowerCamelCase				,"""word"""    )    )				,output.text    )

      # output times
      __SCREAMING_SNAKE_CASE      							=       torch.tensor(self.get_from_offsets(lowerCamelCase				,"""start_time"""    )    )
      __SCREAMING_SNAKE_CASE      							=       torch.tensor(self.get_from_offsets(lowerCamelCase				,"""end_time"""    )    )

      # fmt: off
      __SCREAMING_SNAKE_CASE      							=       torch.tensor([1.4_199, 1.6_599, 2.2_599, 3.0, 3.24, 3.5_999, 3.7_999, 4.0_999, 4.26, 4.94, 5.28, 5.6_599, 5.78, 5.94, 6.32, 6.5_399, 6.6_599]    )
      __SCREAMING_SNAKE_CASE      							=       torch.tensor([1.5_399, 1.8_999, 2.9, 3.16, 3.5_399, 3.72, 4.0_199, 4.1_799, 4.76, 5.1_599, 5.5_599, 5.6_999, 5.86, 6.1_999, 6.38, 6.6_199, 6.94]    )
      # fmt: on

      self.assertTrue(torch.allclose(lowerCamelCase				,lowerCamelCase				,atol=0.01    )    )
      self.assertTrue(torch.allclose(lowerCamelCase				,lowerCamelCase				,atol=0.01    )    )












'''simple docstring'''

import os
import string
import sys


a        =						1 << 8

a        =						{
    "tab": ord("\t"),
    "newline": ord("\r"),
    "esc": 27,
    "up": 65 + ARROW_KEY_FLAG,
    "down": 66 + ARROW_KEY_FLAG,
    "right": 67 + ARROW_KEY_FLAG,
    "left": 68 + ARROW_KEY_FLAG,
    "mod_int": 91,
    "undefined": sys.maxsize,
    "interrupt": 3,
    "insert": 50,
    "delete": 51,
    "pg_up": 53,
    "pg_down": 54,
}

a        =						KEYMAP["up"]
a        =						KEYMAP["left"]

if sys.platform == "win32":
    a        =						[]
    a        =						{
        b"\xe0H": KEYMAP["up"] - ARROW_KEY_FLAG,
        b"\x00H": KEYMAP["up"] - ARROW_KEY_FLAG,
        b"\xe0P": KEYMAP["down"] - ARROW_KEY_FLAG,
        b"\x00P": KEYMAP["down"] - ARROW_KEY_FLAG,
        b"\xe0M": KEYMAP["right"] - ARROW_KEY_FLAG,
        b"\x00M": KEYMAP["right"] - ARROW_KEY_FLAG,
        b"\xe0K": KEYMAP["left"] - ARROW_KEY_FLAG,
        b"\x00K": KEYMAP["left"] - ARROW_KEY_FLAG,
    }

for i in range(10):
    a        =						ord(str(i))

def 						__magic_name__       (							)						->					Union[str, Any]:

   '''simple docstring'''







   if os.name == "nt":
      import msvcrt

      __SCREAMING_SNAKE_CASE      							=       """mbcs"""
      # Flush the keyboard buffer
      while msvcrt.kbhit():
         msvcrt.getch()
      if len(__UpperCAmelCase      ) == 0:
         # Read the keystroke
         __SCREAMING_SNAKE_CASE      							=       msvcrt.getch()

         # If it is a prefix char, get second part
         if ch in (b"\x00", b"\xe0"):
            __SCREAMING_SNAKE_CASE      							=       ch + msvcrt.getch()
            # Translate actual Win chars to bullet char types
            try:
               __SCREAMING_SNAKE_CASE      							=       chr(WIN_KEYMAP[cha]      )
               WIN_CH_BUFFER.append(chr(KEYMAP["""mod_int"""]      )      )
               WIN_CH_BUFFER.append(__UpperCAmelCase      )
               if ord(__UpperCAmelCase      ) in (
                   KEYMAP["insert"] - 1 << 9,
                   KEYMAP["delete"] - 1 << 9,
                   KEYMAP["pg_up"] - 1 << 9,
                   KEYMAP["pg_down"] - 1 << 9,
               ):
                  WIN_CH_BUFFER.append(chr(126      )      )
               __SCREAMING_SNAKE_CASE      							=       chr(KEYMAP["""esc"""]      )
            except KeyError:
               __SCREAMING_SNAKE_CASE      							=       cha[1]
         else:
            __SCREAMING_SNAKE_CASE      							=       ch.decode(__UpperCAmelCase      )
      else:
         __SCREAMING_SNAKE_CASE      							=       WIN_CH_BUFFER.pop(0      )
   elif os.name == "posix":
      import termios
      import tty

      __SCREAMING_SNAKE_CASE      							=       sys.stdin.fileno()
      __SCREAMING_SNAKE_CASE      							=       termios.tcgetattr(__UpperCAmelCase      )
      try:
         tty.setraw(__UpperCAmelCase      )
         __SCREAMING_SNAKE_CASE      							=       sys.stdin.read(1      )
      finally:
         termios.tcsetattr(__UpperCAmelCase							,	termios.TCSADRAIN							,	__UpperCAmelCase      )
   return ch







def 						__magic_name__       (							)						->					List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
   if ord(__UpperCAmelCase      ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
      return char

   elif ord(__UpperCAmelCase      ) == KEYMAP["esc"]:
      __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
      if ord(__UpperCAmelCase      ) == KEYMAP["mod_int"]:
         __SCREAMING_SNAKE_CASE      							=       get_raw_chars()
         if ord(__UpperCAmelCase      ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(__UpperCAmelCase      ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
            return chr(ord(__UpperCAmelCase      ) + ARROW_KEY_FLAG      )
         else:
            return KEYMAP["undefined"]
      else:
         return get_raw_chars()

   else:
      if char in string.printable:
         return char
      else:
         return KEYMAP["undefined"]





