





"""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 					__magic_name__		(			unittest.TestCase     ):






       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Dict       							=				'''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
              lowercase		:Any       							=				dict(zip(UpperCAmelCase_  ,     range(len(UpperCAmelCase_				)				)				)				)

              lowercase		:Union[str, Any]       							=				{
                  '''unk_token''': '''<unk>''',
                  '''bos_token''': '''<s>''',
                  '''eos_token''': '''</s>''',
              }
              lowercase		:List[Any]       							=				{
                  '''feature_size''': 1,
                  '''padding_value''': 0.0,
                  '''sampling_rate''': 1_6_0_0_0,
                  '''return_attention_mask''': False,
                  '''do_normalize''': True,
              }

              lowercase		:int       							=				tempfile.mkdtemp()
              lowercase		:Union[str, Any]       							=				os.path.join(self.tmpdirname  ,     VOCAB_FILES_NAMES['''vocab_file''']				)
              lowercase		:Union[str, Any]       							=				os.path.join(self.tmpdirname  ,     UpperCAmelCase_				)
              with open(self.vocab_file  ,     '''w'''  ,     encoding='''utf-8'''				) as fp:
                     fp.write(json.dumps(UpperCAmelCase_				) + '''\n'''				)

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

              # load decoder from hub
              lowercase		:int       							=				'''hf-internal-testing/ngram-beam-search-decoder'''






       def  __snake_case						(   self  :    Any  ,     **snake_case__  :    str				):

              '''simple docstring'''






              lowercase		:Any       							=				self.add_kwargs_tokens_map.copy()
              kwargs.update(UpperCAmelCase_				)
              return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname  ,     **UpperCAmelCase_				)






       def  __snake_case						(   self  :    List[Any]  ,     **snake_case__  :    int				):

              '''simple docstring'''






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






       def  __snake_case						(   self  :    Union[str, Any]  ,     **snake_case__  :    Dict				):

              '''simple docstring'''






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






       def  __snake_case						(   self  :    Tuple				):

              '''simple docstring'''






              shutil.rmtree(self.tmpdirname				)






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:Optional[Any]       							=				self.get_tokenizer()
              lowercase		:List[Any]       							=				self.get_feature_extractor()
              lowercase		:Tuple       							=				self.get_decoder()

              lowercase		:Optional[int]       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

              processor.save_pretrained(self.tmpdirname				)
              lowercase		:List[Any]       							=				WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname				)

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

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

              # 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  ,     UpperCAmelCase_				)






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:Any       							=				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
              lowercase		:Optional[Any]       							=				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  __snake_case						(   self  :    List[Any]				):

              '''simple docstring'''






              lowercase		:Optional[Any]       							=				self.get_tokenizer()
              # add token to trigger raise
              tokenizer.add_tokens(['''xx''']				)
              with self.assertRaisesRegex(UpperCAmelCase_  ,     '''include'''				):
                     WavaVecaProcessorWithLM(
                         tokenizer=UpperCAmelCase_  ,     feature_extractor=self.get_feature_extractor()  ,     decoder=self.get_decoder()				)






       def  __snake_case						(   self  :    Tuple				):

              '''simple docstring'''






              lowercase		:Any       							=				self.get_feature_extractor()
              lowercase		:str       							=				self.get_tokenizer()
              lowercase		:Any       							=				self.get_decoder()

              lowercase		:Dict       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

              lowercase		:Any       							=				floats_list((3, 1_0_0_0)				)

              lowercase		:str       							=				feature_extractor(UpperCAmelCase_  ,     return_tensors='''np'''				)
              lowercase		:str       							=				processor(UpperCAmelCase_  ,     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  :    str				):

              '''simple docstring'''






              lowercase		:Optional[Any]       							=				self.get_feature_extractor()
              lowercase		:Dict       							=				self.get_tokenizer()
              lowercase		:str       							=				self.get_decoder()

              lowercase		:List[str]       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

              lowercase		:Union[str, Any]       							=				'''This is a test string'''

              lowercase		:Union[str, Any]       							=				processor(text=UpperCAmelCase_				)

              lowercase		:Union[str, Any]       							=				tokenizer(UpperCAmelCase_				)

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






       def  __snake_case						(   self  :    Dict  ,     snake_case__  :    Tuple=(2, 1_0, 1_6)  ,     snake_case__  :    Optional[int]=7_7				):

              '''simple docstring'''






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






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:Tuple       							=				self.get_feature_extractor()
              lowercase		:Dict       							=				self.get_tokenizer()
              lowercase		:List[Any]       							=				self.get_decoder()

              lowercase		:Tuple       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

              lowercase		:int       							=				self._get_dummy_logits(shape=(1_0, 1_6)  ,     seed=1_3				)

              lowercase		:str       							=				processor.decode(UpperCAmelCase_				)

              lowercase		:List[Any]       							=				decoder.decode_beams(UpperCAmelCase_				)[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  __snake_case						(   self  :    Optional[int]  ,     snake_case__  :    Optional[Any]				):

              '''simple docstring'''






              lowercase		:str       							=				self.get_feature_extractor()
              lowercase		:Optional[Any]       							=				self.get_tokenizer()
              lowercase		:List[str]       							=				self.get_decoder()

              lowercase		:Dict       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

              lowercase		:Dict       							=				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:
                     lowercase		:Union[str, Any]       							=				processor.batch_decode(UpperCAmelCase_				)
              else:
                     with get_context(UpperCAmelCase_				).Pool() as pool:
                            lowercase		:List[str]       							=				processor.batch_decode(UpperCAmelCase_  ,     UpperCAmelCase_				)

              lowercase		:Optional[int]       							=				list(UpperCAmelCase_				)

              with get_context('''fork'''				).Pool() as p:
                     lowercase		:Optional[int]       							=				decoder.decode_beams_batch(UpperCAmelCase_  ,     UpperCAmelCase_				)

              lowercase							,  lowercase							,  lowercase		:Any       							=				[], [], []
              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(UpperCAmelCase_  ,     decoded_processor.text				)
              self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>''']  ,     decoded_processor.text				)
              self.assertListEqual(UpperCAmelCase_  ,     decoded_processor.logit_score				)
              self.assertListEqual(UpperCAmelCase_  ,     decoded_processor.lm_score				)






       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Optional[Any]       							=				self.get_feature_extractor()
              lowercase		:Optional[Any]       							=				self.get_tokenizer()
              lowercase		:int       							=				self.get_decoder()

              lowercase		:Dict       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

              lowercase		:Dict       							=				self._get_dummy_logits()

              lowercase		:Optional[int]       							=				1_5
              lowercase		:Any       							=				-20.0
              lowercase		:Dict       							=				-4.0

              lowercase		:List[str]       							=				processor.batch_decode(
                  UpperCAmelCase_  ,     beam_width=UpperCAmelCase_  ,     beam_prune_logp=UpperCAmelCase_  ,     token_min_logp=UpperCAmelCase_  ,     )
              lowercase		:str       							=				decoded_processor_out.text

              lowercase		:str       							=				list(UpperCAmelCase_				)

              with get_context('''fork'''				).Pool() as pool:
                     lowercase		:int       							=				decoder.decode_beams_batch(
                         UpperCAmelCase_  ,     UpperCAmelCase_  ,     beam_width=UpperCAmelCase_  ,     beam_prune_logp=UpperCAmelCase_  ,     token_min_logp=UpperCAmelCase_  ,     )

              lowercase		:Dict       							=				[d[0][0] for d in decoded_decoder_out]
              lowercase		:Tuple       							=				[d[0][2] for d in decoded_decoder_out]
              lowercase		:Any       							=				[d[0][3] for d in decoded_decoder_out]

              self.assertListEqual(UpperCAmelCase_  ,     UpperCAmelCase_				)
              self.assertListEqual(['''</s> <s> <s>''', '''<s> <s> <s>''']  ,     UpperCAmelCase_				)

              self.assertTrue(np.array_equal(UpperCAmelCase_  ,     decoded_processor_out.logit_score				)				)
              self.assertTrue(np.allclose([-20.0_54, -18.4_47]  ,     UpperCAmelCase_  ,     atol=1e-3				)				)

              self.assertTrue(np.array_equal(UpperCAmelCase_  ,     decoded_processor_out.lm_score				)				)
              self.assertTrue(np.allclose([-15.5_54, -13.94_74]  ,     UpperCAmelCase_  ,     atol=1e-3				)				)






       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				self.get_feature_extractor()
              lowercase		:List[str]       							=				self.get_tokenizer()
              lowercase		:str       							=				self.get_decoder()

              lowercase		:List[Any]       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

              lowercase		:Tuple       							=				self._get_dummy_logits()

              lowercase		:str       							=				2.0
              lowercase		:str       							=				5.0
              lowercase		:Optional[Any]       							=				-20.0
              lowercase		:Tuple       							=				True

              lowercase		:List[str]       							=				processor.batch_decode(
                  UpperCAmelCase_  ,     alpha=UpperCAmelCase_  ,     beta=UpperCAmelCase_  ,     unk_score_offset=UpperCAmelCase_  ,     lm_score_boundary=UpperCAmelCase_  ,     )
              lowercase		:Optional[Any]       							=				decoded_processor_out.text

              lowercase		:List[Any]       							=				list(UpperCAmelCase_				)
              decoder.reset_params(
                  alpha=UpperCAmelCase_  ,     beta=UpperCAmelCase_  ,     unk_score_offset=UpperCAmelCase_  ,     lm_score_boundary=UpperCAmelCase_  ,     )

              with get_context('''fork'''				).Pool() as pool:
                     lowercase		:Tuple       							=				decoder.decode_beams_batch(
                         UpperCAmelCase_  ,     UpperCAmelCase_  ,     )

              lowercase		:Dict       							=				[d[0][0] for d in decoded_decoder_out]

              self.assertListEqual(UpperCAmelCase_  ,     UpperCAmelCase_				)
              self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>''']  ,     UpperCAmelCase_				)
              lowercase		:Dict       							=				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  ,     UpperCAmelCase_				)






       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''				)

              lowercase		:List[Any]       							=				processor.decoder.model_container[processor.decoder._model_key]
              lowercase		:str       							=				Path(language_model._kenlm_model.path.decode('''utf-8'''				)				).parent.parent.absolute()

              lowercase		:int       							=				os.listdir(UpperCAmelCase_				)
              lowercase		:int       							=				['''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(UpperCAmelCase_  ,     UpperCAmelCase_				)






       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              lowercase		:Tuple       							=				snapshot_download('''hf-internal-testing/processor_with_lm'''				)

              lowercase		:List[str]       							=				WavaVecaProcessorWithLM.from_pretrained(UpperCAmelCase_				)

              lowercase		:Any       							=				processor.decoder.model_container[processor.decoder._model_key]
              lowercase		:Any       							=				Path(language_model._kenlm_model.path.decode('''utf-8'''				)				).parent.parent.absolute()

              lowercase		:str       							=				os.listdir(UpperCAmelCase_				)
              lowercase		:Any       							=				os.listdir(UpperCAmelCase_				)

              local_decoder_files.sort()
              expected_decoder_files.sort()

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






       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              lowercase		:Optional[Any]       							=				WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''				)
              lowercase		:int       							=				AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm'''				)

              lowercase		:int       							=				floats_list((3, 1_0_0_0)				)

              lowercase		:Dict       							=				processor_wavaveca(UpperCAmelCase_  ,     return_tensors='''np'''				)
              lowercase		:int       							=				processor_auto(UpperCAmelCase_  ,     return_tensors='''np'''				)

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

              lowercase		:Tuple       							=				self._get_dummy_logits()

              lowercase		:Tuple       							=				processor_wavaveca.batch_decode(UpperCAmelCase_				)
              lowercase		:Union[str, Any]       							=				processor_auto.batch_decode(UpperCAmelCase_				)

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






       def  __snake_case						(   self  :    List[Any]				):

              '''simple docstring'''






              lowercase		:Any       							=				self.get_feature_extractor()
              lowercase		:List[Any]       							=				self.get_tokenizer()
              lowercase		:str       							=				self.get_decoder()

              lowercase		:str       							=				WavaVecaProcessorWithLM(tokenizer=UpperCAmelCase_  ,     feature_extractor=UpperCAmelCase_  ,     decoder=UpperCAmelCase_				)

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






       @staticmethod
       def  __snake_case						(   snake_case__  :    Optional[int]  ,     snake_case__  :    List[Any]				):

              '''simple docstring'''






              lowercase		:Any       							=				[d[key] for d in offsets]
              return retrieved_list






       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''				)
              lowercase		:Dict       							=				self._get_dummy_logits()[0]

              lowercase		:List[str]       							=				processor.decode(UpperCAmelCase_  ,     output_word_offsets=UpperCAmelCase_				)
              # 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(UpperCAmelCase_  ,     UpperCAmelCase_				)				)

              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  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:Optional[Any]       							=				WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''				)
              lowercase		:str       							=				self._get_dummy_logits()

              lowercase		:str       							=				processor.batch_decode(UpperCAmelCase_  ,     output_word_offsets=UpperCAmelCase_				)

              # 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(UpperCAmelCase_  ,     UpperCAmelCase_				)				)

              self.assertListEqual(
                  [''' '''.join(self.get_from_offsets(UpperCAmelCase_  ,     '''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  __snake_case						(   self  :    Optional[Any]				):

              '''simple docstring'''






              import torch

              lowercase		:Optional[Any]       							=				load_dataset('''common_voice'''  ,     '''en'''  ,     split='''train'''  ,     streaming=UpperCAmelCase_				)
              lowercase		:Dict       							=				ds.cast_column('''audio'''  ,     datasets.Audio(sampling_rate=1_6_0_0_0				)				)
              lowercase		:str       							=				iter(UpperCAmelCase_				)
              lowercase		:List[str]       							=				next(UpperCAmelCase_				)

              lowercase		:Any       							=				AutoProcessor.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''				)
              lowercase		:List[str]       							=				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
              lowercase		:List[str]       							=				processor(sample['''audio''']['''array''']  ,     return_tensors='''pt'''				).input_values

              with torch.no_grad():
                     lowercase		:Any       							=				model(UpperCAmelCase_				).logits.cpu().numpy()

              lowercase		:Tuple       							=				processor.decode(logits[0]  ,     output_word_offsets=UpperCAmelCase_				)

              lowercase		:Optional[Any]       							=				model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
              lowercase		:Tuple       							=				[
                  {
                      '''start_time''': d['''start_offset'''] * time_offset,
                      '''end_time''': d['''end_offset'''] * time_offset,
                      '''word''': d['''word'''],
                  }
                  for d in output['''word_offsets''']
              ]

              lowercase		:Optional[Any]       							=				'''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(UpperCAmelCase_  ,     '''word'''				)				)  ,     UpperCAmelCase_				)
              self.assertEqual(''' '''.join(self.get_from_offsets(UpperCAmelCase_  ,     '''word'''				)				)  ,     output.text				)

              # output times
              lowercase		:List[str]       							=				torch.tensor(self.get_from_offsets(UpperCAmelCase_  ,     '''start_time'''				)				)
              lowercase		:Union[str, Any]       							=				torch.tensor(self.get_from_offsets(UpperCAmelCase_  ,     '''end_time'''				)				)

              # fmt: off
              lowercase		:Any       							=				torch.tensor([1.41_99, 1.65_99, 2.25_99, 3.0, 3.24, 3.59_99, 3.79_99, 4.09_99, 4.26, 4.94, 5.28, 5.65_99, 5.78, 5.94, 6.32, 6.53_99, 6.65_99]				)
              lowercase		:Optional[int]       							=				torch.tensor([1.53_99, 1.89_99, 2.9, 3.16, 3.53_99, 3.72, 4.01_99, 4.17_99, 4.76, 5.15_99, 5.55_99, 5.69_99, 5.86, 6.19_99, 6.38, 6.61_99, 6.94]				)
              # fmt: on

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





"""simple docstring"""



from __future__ import annotations

from itertools import permutations
from random import randint
from timeit import repeat






def       lowerCamelCase					()     ->							tuple[list[int], int]:
       lowercase		:Any       							=				[randint(-1000				,				1000) for i in range(10)]
       lowercase		:Any       							=				randint(-5000				,				5000)
       return (arr, r)


UpperCAmelCase      		=			make_dataset()






def       lowerCamelCase					(a_						:list[int]				,				a_						:int)     ->							tuple[int, ...]:
       for triplet in permutations(a_				,				3):
              if sum(a_) == target:
                     return tuple(sorted(a_))
       return (0, 0, 0)






def       lowerCamelCase					(a_						:list[int]				,				a_						:int)     ->							tuple[int, int, int]:
       arr.sort()
       lowercase		:Union[str, Any]       							=				len(a_)
       for i in range(n - 1):
              lowercase							,  lowercase		:Union[str, Any]       							=				i + 1, n - 1
              while left < right:
                     if arr[i] + arr[left] + arr[right] == target:
                            return (arr[i], arr[left], arr[right])
                     elif arr[i] + arr[left] + arr[right] < target:
                            left += 1
                     elif arr[i] + arr[left] + arr[right] > target:
                            right -= 1
       return (0, 0, 0)






def       lowerCamelCase					()     ->							tuple[float, float]:
       lowercase		:int       							=				'''
from __main__ import dataset, triplet_sum1, triplet_sum2
'''
       lowercase		:Optional[Any]       							=				'''
triplet_sum1(*dataset)
'''
       lowercase		:Union[str, Any]       							=				'''
triplet_sum2(*dataset)
'''
       lowercase		:Dict       							=				repeat(setup=a_				,				stmt=a_				,				repeat=5				,				number=1_0000)
       lowercase		:Optional[int]       							=				repeat(setup=a_				,				stmt=a_				,				repeat=5				,				number=1_0000)
       return (min(a_), min(a_))


if __name__ == "__main__":
 from doctest import testmod

 testmod()
 UpperCAmelCase      		=			solution_times()
 print(F"""The time for naive implementation is {times[0]}.""")
 print(F"""The time for optimized implementation is {times[1]}.""")

