


"""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      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

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

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

					# load decoder from hub
					lowerCAmelCase_      							=			'''hf-internal-testing/ngram-beam-search-decoder'''







				def      lowerCamelCase_     ( self      ,	**UpperCAmelCase   ):

					'''simple docstring'''






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







				def      lowerCamelCase_     ( self      ,	**UpperCAmelCase   ):

					'''simple docstring'''






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







				def      lowerCamelCase_     ( self      ,	**UpperCAmelCase   ):

					'''simple docstring'''






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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					shutil.rmtree(self.tmpdirname   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

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

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

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

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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			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
					lowerCAmelCase_      							=			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      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

					lowerCAmelCase_      							=			floats_list((3, 1000)   )

					lowerCAmelCase_      							=			feature_extractor(__SCREAMING_SNAKE_CASE      ,	return_tensors='''np'''   )
					lowerCAmelCase_      							=			processor(__SCREAMING_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      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

					lowerCAmelCase_      							=			'''This is a test string'''

					lowerCAmelCase_      							=			processor(text=__SCREAMING_SNAKE_CASE   )

					lowerCAmelCase_      							=			tokenizer(__SCREAMING_SNAKE_CASE   )

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







				def      lowerCamelCase_     ( self      ,	UpperCAmelCase=(2, 10, 16)      ,	UpperCAmelCase=77   ):

					'''simple docstring'''






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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

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

					lowerCAmelCase_      							=			processor.decode(__SCREAMING_SNAKE_CASE   )

					lowerCAmelCase_      							=			decoder.decode_beams(__SCREAMING_SNAKE_CASE   )[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      lowerCamelCase_     ( self      ,	UpperCAmelCase   ):

					'''simple docstring'''






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

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

					lowerCAmelCase_      							=			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:
						lowerCAmelCase_      							=			processor.batch_decode(__SCREAMING_SNAKE_CASE   )
					else:
						with get_context(__SCREAMING_SNAKE_CASE   ).Pool() as pool:
							lowerCAmelCase_      							=			processor.batch_decode(__SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE   )

					lowerCAmelCase_      							=			list(__SCREAMING_SNAKE_CASE   )

					with get_context('''fork'''   ).Pool() as p:
						lowerCAmelCase_      							=			decoder.decode_beams_batch(__SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE   )

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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

					lowerCAmelCase_      							=			self._get_dummy_logits()

					lowerCAmelCase_      							=			15
					lowerCAmelCase_      							=			-2_0.0
					lowerCAmelCase_      							=			-4.0

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

					lowerCAmelCase_      							=			list(__SCREAMING_SNAKE_CASE   )

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

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

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

					self.assertTrue(np.array_equal(__SCREAMING_SNAKE_CASE      ,	decoded_processor_out.logit_score   )   )
					self.assertTrue(np.allclose([-2_0.0_5_4, -1_8.4_4_7]      ,	__SCREAMING_SNAKE_CASE      ,	atol=1E-3   )   )

					self.assertTrue(np.array_equal(__SCREAMING_SNAKE_CASE      ,	decoded_processor_out.lm_score   )   )
					self.assertTrue(np.allclose([-1_5.5_5_4, -1_3.9_4_7_4]      ,	__SCREAMING_SNAKE_CASE      ,	atol=1E-3   )   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

					lowerCAmelCase_      							=			self._get_dummy_logits()

					lowerCAmelCase_      							=			2.0
					lowerCAmelCase_      							=			5.0
					lowerCAmelCase_      							=			-2_0.0
					lowerCAmelCase_      							=			True

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

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

					with get_context('''fork'''   ).Pool() as pool:
						lowerCAmelCase_      							=			decoder.decode_beams_batch(
						    __SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE      ,	)

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

					self.assertListEqual(__SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE   )
					self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>''']      ,	__SCREAMING_SNAKE_CASE   )
					lowerCAmelCase_      							=			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      ,	-2_0.0   )
					self.assertEqual(lm_model.score_boundary      ,	__SCREAMING_SNAKE_CASE   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''   )

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

					lowerCAmelCase_      							=			os.listdir(__SCREAMING_SNAKE_CASE   )
					lowerCAmelCase_      							=			['''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(__SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE   )







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			snapshot_download('''hf-internal-testing/processor_with_lm'''   )

					lowerCAmelCase_      							=			WavaVecaProcessorWithLM.from_pretrained(__SCREAMING_SNAKE_CASE   )

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

					lowerCAmelCase_      							=			os.listdir(__SCREAMING_SNAKE_CASE   )
					lowerCAmelCase_      							=			os.listdir(__SCREAMING_SNAKE_CASE   )

					local_decoder_files.sort()
					expected_decoder_files.sort()

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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					lowerCAmelCase_      							=			WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''   )
					lowerCAmelCase_      							=			AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm'''   )

					lowerCAmelCase_      							=			floats_list((3, 1000)   )

					lowerCAmelCase_      							=			processor_wavaveca(__SCREAMING_SNAKE_CASE      ,	return_tensors='''np'''   )
					lowerCAmelCase_      							=			processor_auto(__SCREAMING_SNAKE_CASE      ,	return_tensors='''np'''   )

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

					lowerCAmelCase_      							=			self._get_dummy_logits()

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

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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

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

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







				@staticmethod
				def      lowerCamelCase_     ( UpperCAmelCase      ,	UpperCAmelCase   ):

					'''simple docstring'''






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







				def      lowerCamelCase_     ( self   ):

					'''simple docstring'''






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

					lowerCAmelCase_      							=			processor.decode(__SCREAMING_SNAKE_CASE      ,	output_word_offsets=__SCREAMING_SNAKE_CASE   )
					# 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(__SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE   )   )

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

					'''simple docstring'''






					lowerCAmelCase_      							=			WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''   )
					lowerCAmelCase_      							=			self._get_dummy_logits()

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

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

					self.assertListEqual(
					    [''' '''.join(self.get_from_offsets(__SCREAMING_SNAKE_CASE      ,	'''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      lowerCamelCase_     ( self   ):

					'''simple docstring'''






					import torch

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

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

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

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

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

					lowerCAmelCase_      							=			'''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(__SCREAMING_SNAKE_CASE      ,	'''word'''   )   )      ,	__SCREAMING_SNAKE_CASE   )
					self.assertEqual(''' '''.join(self.get_from_offsets(__SCREAMING_SNAKE_CASE      ,	'''word'''   )   )      ,	output.text   )

					# output times
					lowerCAmelCase_      							=			torch.tensor(self.get_from_offsets(__SCREAMING_SNAKE_CASE      ,	'''start_time'''   )   )
					lowerCAmelCase_      							=			torch.tensor(self.get_from_offsets(__SCREAMING_SNAKE_CASE      ,	'''end_time'''   )   )

					# fmt: off
					lowerCAmelCase_      							=			torch.tensor([1.4_1_9_9, 1.6_5_9_9, 2.2_5_9_9, 3.0, 3.2_4, 3.5_9_9_9, 3.7_9_9_9, 4.0_9_9_9, 4.2_6, 4.9_4, 5.2_8, 5.6_5_9_9, 5.7_8, 5.9_4, 6.3_2, 6.5_3_9_9, 6.6_5_9_9]   )
					lowerCAmelCase_      							=			torch.tensor([1.5_3_9_9, 1.8_9_9_9, 2.9, 3.1_6, 3.5_3_9_9, 3.7_2, 4.0_1_9_9, 4.1_7_9_9, 4.7_6, 5.1_5_9_9, 5.5_5_9_9, 5.6_9_9_9, 5.8_6, 6.1_9_9_9, 6.3_8, 6.6_1_9_9, 6.9_4]   )
					# fmt: on

					self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE      ,	atol=0.0_1   )   )
					self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE      ,	__SCREAMING_SNAKE_CASE      ,	atol=0.0_1   )   )





'''simple docstring'''



from collections import deque







def       _UpperCamelCase			(_lowerCamelCase				:  Union[str, Any]						)-> Optional[int]:




     '''simple docstring'''





     __snake_case            =	len(_lowerCamelCase						)
     __snake_case            =	deque()
     __snake_case            =	[False for _ in range(_lowerCamelCase						)]
     __snake_case            =	[-1 for _ in range(_lowerCamelCase						)]
     __snake_case            =	index_of[:]

     def strong_connect(_lowerCamelCase				:  Any ,						_lowerCamelCase				:  Dict ,						_lowerCamelCase				:  List[str]						):
          __snake_case            =	index  # the number when this node is seen
          __snake_case            =	index  # lowest rank node reachable from here
          index += 1
          stack.append(_lowerCamelCase						)
          __snake_case            =	True

          for w in g[v]:
               if index_of[w] == -1:
                    __snake_case            =	strong_connect(_lowerCamelCase ,						_lowerCamelCase ,						_lowerCamelCase						)
                    __snake_case            =	(
                        lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
                    )
               elif on_stack[w]:
                    __snake_case            =	(
                        lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
                    )

          if lowlink_of[v] == index_of[v]:
               __snake_case            =	[]
               __snake_case            =	stack.pop()
               __snake_case            =	False
               component.append(_lowerCamelCase						)
               while w != v:
                    __snake_case            =	stack.pop()
                    __snake_case            =	False
                    component.append(_lowerCamelCase						)
               components.append(_lowerCamelCase						)
          return index

     __snake_case            =	[]
     for v in range(_lowerCamelCase						):
          if index_of[v] == -1:
               strong_connect(_lowerCamelCase ,						0 ,						_lowerCamelCase						)

     return components







def       _UpperCamelCase			(_lowerCamelCase				:  Tuple ,						_lowerCamelCase				:  Optional[Any]						)-> Dict:




     '''simple docstring'''





     __snake_case            =	[[] for _ in range(_lowerCamelCase						)]
     for u, v in edges:
          g[u].append(_lowerCamelCase						)
     return g


if __name__ == "__main__":
     # Test
     UpperCAmelCase_							:	List[str]	     =		7
     UpperCAmelCase_							:	int	     =		[0, 0, 1, 2, 3, 3, 4, 4, 6]
     UpperCAmelCase_							:	Dict	     =		[1, 3, 2, 0, 1, 4, 5, 6, 5]
     UpperCAmelCase_							:	List[str]	     =		[(u, v) for u, v in zip(source, target)]
     UpperCAmelCase_							:	Tuple	     =		create_graph(n_vertices, edges)

     assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)






