





'''simple docstring'''



from math import sqrt




def    _lowerCAmelCase						(				lowerCamelCase_			:  int				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (
			    number >= 0
			), "'number' must been an int and positive"

			__lowercase										=							True

			# 0 and 1 are none primes.
			if number <= 1:
						__lowercase										=							False

			for divisor in range(2		,       int(round(sqrt(lowerCamelCase_				)				)				) + 1				):
						# if 'number' divisible by 'divisor' then sets 'status'
						# of false and break up the loop.
						if number % divisor == 0:
									__lowercase										=							False
									break

    # precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'status' must been from type bool"

			return status




def    _lowerCAmelCase						(				lowerCamelCase_			:  Optional[Any]				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (n > 2), "'N' must been an int and > 2"

			# beginList: contains all natural numbers from 2 up to N
			__lowercase										=							list(range(2		,       n + 1				)				)

			__lowercase										=							[]  # this list will be returns.

			# actual sieve of erathostenes
			for i in range(len(lowerCamelCase_				)				):
						for j in range(i + 1		,       len(lowerCamelCase_				)				):
									if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
												__lowercase										=							0

    # filters actual prime numbers.
			__lowercase										=							[x for x in begin_list if x != 0]

			# precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'ans' must been from type list"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Any				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (n > 2), "'N' must been an int and > 2"

			__lowercase										=							[]

			# iterates over all numbers between 2 up to N+1
			# if a number is prime then appends to list 'ans'
			for number in range(2		,       n + 1				):
						if is_prime(lowerCamelCase_				):
									ans.append(lowerCamelCase_				)

    # precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'ans' must been from type list"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  List[str]				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and number >= 0, "'number' must been an int and >= 0"

			__lowercase										=							[]  # this list will be returns of the function.

			# potential prime number factors.

			__lowercase										=							2

			__lowercase										=							number

			if number == 0 or number == 1:
						ans.append(lowerCamelCase_				)

			# if 'number' not prime then builds the prime factorization of 'number'
			elif not is_prime(lowerCamelCase_				):
						while quotient != 1:
									if is_prime(lowerCamelCase_				) and (quotient % factor == 0):
												ans.append(lowerCamelCase_				)
												quotient /= factor
									else:
												factor += 1

			else:
						ans.append(lowerCamelCase_				)

			# precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'ans' must been from type list"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Any				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			__lowercase										=							0

			# prime factorization of 'number'
			__lowercase										=							prime_factorization(lowerCamelCase_				)

			__lowercase										=							max(lowerCamelCase_				)

			# precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'ans' must been from type int"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  List[Any]				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (
			    number >= 0
			), "'number' bust been an int and >= 0"

			__lowercase										=							0

			# prime factorization of 'number'
			__lowercase										=							prime_factorization(lowerCamelCase_				)

			__lowercase										=							min(lowerCamelCase_				)

			# precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'ans' must been from type int"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Tuple				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'number' must been an int"
			assert isinstance(number % 2 == 0		,       lowerCamelCase_				), "compare bust been from type bool"

			return number % 2 == 0




def    _lowerCAmelCase						(				lowerCamelCase_			:  Optional[Any]				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				), "'number' must been an int"
			assert isinstance(number % 2 != 0		,       lowerCamelCase_				), "compare bust been from type bool"

			return number % 2 != 0




def    _lowerCAmelCase						(				lowerCamelCase_			:  int				):
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (number > 2) and is_even(lowerCamelCase_				)
			), "'number' must been an int, even and > 2"

			__lowercase										=							[]  # this list will returned

			# creates a list of prime numbers between 2 up to 'number'
			__lowercase										=							get_prime_numbers(lowerCamelCase_				)
			__lowercase										=							len(lowerCamelCase_				)

			# run variable for while-loops.
			__lowercase										=							0
			__lowercase										=							None

			# exit variable. for break up the loops
			__lowercase										=							True

			while i < len_pn and loop:
						__lowercase										=							i + 1

						while j < len_pn and loop:
									if prime_numbers[i] + prime_numbers[j] == number:
												__lowercase										=							False
												ans.append(prime_numbers[i]				)
												ans.append(prime_numbers[j]				)

									j += 1

						i += 1

			# precondition
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and (len(lowerCamelCase_				) == 2)
			    and (ans[0] + ans[1] == number)
			    and is_prime(ans[0]				)
			    and is_prime(ans[1]				)
			), "'ans' must contains two primes. And sum of elements must been eq 'number'"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Union[str, Any]		,       lowerCamelCase_			:  Union[str, Any]				):
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and (numbera >= 0)
			    and (numbera >= 0)
			), "'number1' and 'number2' must been positive integer."

			__lowercase										=							0

			while numbera != 0:
						__lowercase										=							numbera % numbera
						__lowercase										=							numbera
						__lowercase										=							rest

			# precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (
			    numbera >= 0
			), "'number' must been from type int and positive"

			return numbera




def    _lowerCAmelCase						(				lowerCamelCase_			:  Optional[int]		,       lowerCamelCase_			:  List[Any]				):
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and (numbera >= 1)
			    and (numbera >= 1)
			), "'number1' and 'number2' must been positive integer."

			__lowercase										=							1  # actual answer that will be return.

			# for kgV (x,1)
			if numbera > 1 and numbera > 1:
						# builds the prime factorization of 'number1' and 'number2'
						__lowercase										=							prime_factorization(lowerCamelCase_				)
						__lowercase										=							prime_factorization(lowerCamelCase_				)

			elif numbera == 1 or numbera == 1:
						__lowercase										=							[]
						__lowercase										=							[]
						__lowercase										=							max(lowerCamelCase_		,       lowerCamelCase_				)

			__lowercase										=							0
			__lowercase										=							0

			__lowercase										=							[]  # captured numbers int both 'primeFac1' and 'primeFac2'

			# iterates through primeFac1
			for n in prime_fac_a:
						if n not in done:
									if n in prime_fac_a:
												__lowercase										=							prime_fac_a.count(lowerCamelCase_				)
												__lowercase										=							prime_fac_a.count(lowerCamelCase_				)

												for _ in range(max(lowerCamelCase_		,       lowerCamelCase_				)				):
															ans *= n

									else:
												__lowercase										=							prime_fac_a.count(lowerCamelCase_				)

												for _ in range(lowerCamelCase_				):
															ans *= n

									done.append(lowerCamelCase_				)

    # iterates through primeFac2
			for n in prime_fac_a:
						if n not in done:
									__lowercase										=							prime_fac_a.count(lowerCamelCase_				)

									for _ in range(lowerCamelCase_				):
												ans *= n

									done.append(lowerCamelCase_				)

    # precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (
			    ans >= 0
			), "'ans' must been from type int and positive"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  str				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (n >= 0), "'number' must been a positive int"

			__lowercase										=							0
			__lowercase										=							2  # this variable holds the answer

			while index < n:
						index += 1

						ans += 1  # counts to the next number

						# if ans not prime then
						# runs to the next prime number.
						while not is_prime(lowerCamelCase_				):
									ans += 1

    # precondition
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and is_prime(
			    lowerCamelCase_				), "'ans' must been a prime number and from type int"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Any		,       lowerCamelCase_			:  List[Any]				):
			assert (
			    is_prime(lowerCamelCase_				) and is_prime(lowerCamelCase_				) and (p_number_a < p_number_a)
			), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

			__lowercase										=							p_number_a + 1  # jump to the next number

			__lowercase										=							[]  # this list will be returns.

			# if number is not prime then
			# fetch the next prime number.
			while not is_prime(lowerCamelCase_				):
						number += 1

			while number < p_number_a:
						ans.append(lowerCamelCase_				)

						number += 1

						# fetch the next prime number.
						while not is_prime(lowerCamelCase_				):
									number += 1

    # precondition
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and ans[0] != p_number_a
			    and ans[len(lowerCamelCase_				) - 1] != p_number_a
			), "'ans' must been a list without the arguments"

			# 'ans' contains not 'pNumber1' and 'pNumber2' !
			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Any				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (n >= 1), "'n' must been int and >= 1"

			__lowercase										=							[]  # will be returned.

			for divisor in range(1		,       n + 1				):
						if n % divisor == 0:
									ans.append(lowerCamelCase_				)

    # precondition
			assert ans[0] == 1 and ans[len(lowerCamelCase_				) - 1] == n, "Error in function getDivisiors(...)"

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Tuple				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (
			    number > 1
			), "'number' must been an int and >= 1"

			__lowercase										=							get_divisors(lowerCamelCase_				)

			# precondition
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and (divisors[0] == 1)
			    and (divisors[len(lowerCamelCase_				) - 1] == number)
			), "Error in help-function getDivisiors(...)"

			# summed all divisors up to 'number' (exclusive), hence [:-1]
			return sum(divisors[:-1]				) == number




def    _lowerCAmelCase						(				lowerCamelCase_			:  int		,       lowerCamelCase_			:  List[str]				):
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and (denominator != 0)
			), "The arguments must been from type int and 'denominator' != 0"

			# build the greatest common divisor of numerator and denominator.
			__lowercase										=							gcd(abs(lowerCamelCase_				)		,       abs(lowerCamelCase_				)				)

			# precondition
			assert (
			    isinstance(lowerCamelCase_		,       lowerCamelCase_				)
			    and (numerator % gcd_of_fraction == 0)
			    and (denominator % gcd_of_fraction == 0)
			), "Error in function gcd(...,...)"

			return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)




def    _lowerCAmelCase						(				lowerCamelCase_			:  List[Any]				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (n >= 0), "'n' must been a int and >= 0"

			__lowercase										=							1  # this will be return.

			for factor in range(1		,       n + 1				):
						ans *= factor

			return ans




def    _lowerCAmelCase						(				lowerCamelCase_			:  Optional[Any]				):
			assert isinstance(lowerCamelCase_		,       lowerCamelCase_				) and (n >= 0), "'n' must been an int and >= 0"

			__lowercase										=							0
			__lowercase										=							1
			__lowercase										=							1  # this will be return

			for _ in range(n - 1				):
						__lowercase										=							ans
						ans += fiba
						__lowercase										=							tmp

			return ans












'''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 							__lowercase       (      unittest.TestCase						):







	'''simple docstring'''

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







				'''simple docstring'''





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

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

				__lowercase										=							tempfile.mkdtemp()
				__lowercase										=							os.path.join(self.tmpdirname     ,VOCAB_FILES_NAMES['''vocab_file'''] )
				__lowercase										=							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
				__lowercase										=							'''hf-internal-testing/ngram-beam-search-decoder'''


	def 						_UpperCAmelCase     (self     ,**_lowerCamelCase )							->							List[str]:







				'''simple docstring'''





				__lowercase										=							self.add_kwargs_tokens_map.copy()
				kwargs.update(_lowerCamelCase )
				return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname     ,**_lowerCamelCase )


	def 						_UpperCAmelCase     (self     ,**_lowerCamelCase )							->							List[Any]:







				'''simple docstring'''





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


	def 						_UpperCAmelCase     (self     ,**_lowerCamelCase )							->							Dict:







				'''simple docstring'''





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


	def 						_UpperCAmelCase     (self )							->							Optional[Any]:







				'''simple docstring'''





				shutil.rmtree(self.tmpdirname )


	def 						_UpperCAmelCase     (self )							->							Optional[Any]:







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				processor.save_pretrained(self.tmpdirname )
				__lowercase										=							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 )							->							Any:







				'''simple docstring'''





				__lowercase										=							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										=							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 )							->							Dict:







				'''simple docstring'''





				__lowercase										=							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 )							->							Optional[int]:







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							floats_list((3, 1000) )

				__lowercase										=							feature_extractor(_lowerCamelCase     ,return_tensors='''np''' )
				__lowercase										=							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 )							->							List[Any]:







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							'''This is a test string'''

				__lowercase										=							processor(text=_lowerCamelCase )

				__lowercase										=							tokenizer(_lowerCamelCase )

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


	def 						_UpperCAmelCase     (self     ,_lowerCamelCase=(2, 10, 16)     ,_lowerCamelCase=77 )							->							Optional[int]:







				'''simple docstring'''





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


	def 						_UpperCAmelCase     (self )							->							str:







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

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

				__lowercase										=							processor.decode(_lowerCamelCase )

				__lowercase										=							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     ,_lowerCamelCase )							->							Optional[Any]:







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

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

				__lowercase										=							list(_lowerCamelCase )

				with get_context('''fork''' ).Pool() as p:
							__lowercase										=							decoder.decode_beams_batch(_lowerCamelCase     ,_lowerCamelCase )

				__lowercase						,		__lowercase						,		__lowercase										=							[], [], []
				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 )							->							Any:







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							self._get_dummy_logits()

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

				__lowercase										=							processor.batch_decode(
				    _lowerCamelCase     ,beam_width=_lowerCamelCase     ,beam_prune_logp=_lowerCamelCase     ,token_min_logp=_lowerCamelCase     ,)
				__lowercase										=							decoded_processor_out.text

				__lowercase										=							list(_lowerCamelCase )

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

				__lowercase										=							[d[0][0] for d in decoded_decoder_out]
				__lowercase										=							[d[0][2] for d in decoded_decoder_out]
				__lowercase										=							[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([-2_0.0_5_4, -1_8.4_4_7]     ,_lowerCamelCase     ,atol=1E-3 ) )

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


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







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM(tokenizer=_lowerCamelCase     ,feature_extractor=_lowerCamelCase     ,decoder=_lowerCamelCase )

				__lowercase										=							self._get_dummy_logits()

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

				__lowercase										=							processor.batch_decode(
				    _lowerCamelCase     ,alpha=_lowerCamelCase     ,beta=_lowerCamelCase     ,unk_score_offset=_lowerCamelCase     ,lm_score_boundary=_lowerCamelCase     ,)
				__lowercase										=							decoded_processor_out.text

				__lowercase										=							list(_lowerCamelCase )
				decoder.reset_params(
				    alpha=_lowerCamelCase     ,beta=_lowerCamelCase     ,unk_score_offset=_lowerCamelCase     ,lm_score_boundary=_lowerCamelCase     ,)

				with get_context('''fork''' ).Pool() as pool:
							__lowercase										=							decoder.decode_beams_batch(
							    _lowerCamelCase     ,_lowerCamelCase     ,)

				__lowercase										=							[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 )
				__lowercase										=							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     ,_lowerCamelCase )


	def 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''simple docstring'''





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

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

				__lowercase										=							os.listdir(_lowerCamelCase )
				__lowercase										=							['''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 )							->							List[Any]:







				'''simple docstring'''





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

				__lowercase										=							WavaVecaProcessorWithLM.from_pretrained(_lowerCamelCase )

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

				__lowercase										=							os.listdir(_lowerCamelCase )
				__lowercase										=							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 )							->							Dict:







				'''simple docstring'''





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

				__lowercase										=							floats_list((3, 1000) )

				__lowercase										=							processor_wavaveca(_lowerCamelCase     ,return_tensors='''np''' )
				__lowercase										=							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 )

				__lowercase										=							self._get_dummy_logits()

				__lowercase										=							processor_wavaveca.batch_decode(_lowerCamelCase )
				__lowercase										=							processor_auto.batch_decode(_lowerCamelCase )

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


	def 						_UpperCAmelCase     (self )							->							Dict:







				'''simple docstring'''





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

				__lowercase										=							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     ,_lowerCamelCase )							->							Optional[Any]:







				'''simple docstring'''





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


	def 						_UpperCAmelCase     (self )							->							Optional[int]:







				'''simple docstring'''





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

				__lowercase										=							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 )							->							Optional[Any]:







				'''simple docstring'''





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

				__lowercase										=							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 )							->							List[Any]:







				'''simple docstring'''





				import torch

				__lowercase										=							load_dataset('''common_voice'''     ,'''en'''     ,split='''train'''     ,streaming=_lowerCamelCase )
				__lowercase										=							ds.cast_column('''audio'''     ,datasets.Audio(sampling_rate=16000 ) )
				__lowercase										=							iter(_lowerCamelCase )
				__lowercase										=							next(_lowerCamelCase )

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

				with torch.no_grad():
							__lowercase										=							model(_lowerCamelCase ).logits.cpu().numpy()

				__lowercase										=							processor.decode(logits[0]     ,output_word_offsets=_lowerCamelCase )

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

				__lowercase										=							'''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
				__lowercase										=							torch.tensor(self.get_from_offsets(_lowerCamelCase     ,'''start_time''' ) )
				__lowercase										=							torch.tensor(self.get_from_offsets(_lowerCamelCase     ,'''end_time''' ) )

				# fmt: off
				__lowercase										=							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] )
				__lowercase										=							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(_lowerCamelCase     ,_lowerCamelCase     ,atol=0.0_1 ) )
				self.assertTrue(torch.allclose(_lowerCamelCase     ,_lowerCamelCase     ,atol=0.0_1 ) )





