




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






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      '| <pad> <unk> <s> </s> a b c d e f g h i j k'.split()
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      dict(zip(snake_case__      ,range(len(snake_case__ ) ) ) )

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

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

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

							# load decoder from hub
							SCREAMING_SNAKE_CASE_   : List[str]					  =      'hf-internal-testing/ngram-beam-search-decoder'






				def 		snake_case	(			self      ,**snake_case__ ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      self.add_kwargs_tokens_map.copy()
							kwargs.update(snake_case__ )
							return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname      ,**snake_case__ )






				def 		snake_case	(			self      ,**snake_case__ ):
							return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname      ,**snake_case__ )






				def 		snake_case	(			self      ,**snake_case__ ):
							return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name      ,**snake_case__ )






				def 		snake_case	(			self ):
							shutil.rmtree(self.tmpdirname )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : str					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : Dict					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=snake_case__ )

							processor.save_pretrained(self.tmpdirname )
							SCREAMING_SNAKE_CASE_   : Dict					  =      WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname )

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

							# feature extractor
							self.assertEqual(processor.feature_extractor.to_json_string()      ,feature_extractor.to_json_string() )
							self.assertIsInstance(processor.feature_extractor      ,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      ,snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      WavaVecaProcessorWithLM(
							    tokenizer=self.get_tokenizer()      ,feature_extractor=self.get_feature_extractor()      ,decoder=self.get_decoder() )
							processor.save_pretrained(self.tmpdirname )

							# make sure that error is thrown when decoder alphabet doesn't match
							SCREAMING_SNAKE_CASE_   : int					  =      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 ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      self.get_tokenizer()
							# add token to trigger raise
							tokenizer.add_tokens(['xx'] )
							with self.assertRaisesRegex(snake_case__      ,'include' ):
										WavaVecaProcessorWithLM(
										    tokenizer=snake_case__      ,feature_extractor=self.get_feature_extractor()      ,decoder=self.get_decoder() )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Any					  =      floats_list((3, 1000) )

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      feature_extractor(snake_case__      ,return_tensors='np' )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      processor(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 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : int					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : Any					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : str					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Dict					  =      'This is a test string'

							SCREAMING_SNAKE_CASE_   : Dict					  =      processor(text=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      tokenizer(snake_case__ )

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






				def 		snake_case	(			self      ,snake_case__=(2, 10, 16)      ,snake_case__=77 ):
							np.random.seed(snake_case__ )
							return np.random.rand(*snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : List[str]					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : str					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      self._get_dummy_logits(shape=(10, 16)      ,seed=13 )

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      processor.decode(snake_case__ )

							SCREAMING_SNAKE_CASE_   : str					  =      decoder.decode_beams(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 		snake_case	(			self      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : Any					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=snake_case__ )

							SCREAMING_SNAKE_CASE_   : str					  =      self._get_dummy_logits()

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

							SCREAMING_SNAKE_CASE_   : Any					  =      list(snake_case__ )

							with get_context('fork' ).Pool() as p:
										SCREAMING_SNAKE_CASE_   : Tuple					  =      decoder.decode_beams_batch(snake_case__      ,snake_case__ )

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






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : Dict					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : List[str]					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Dict					  =      self._get_dummy_logits()

							SCREAMING_SNAKE_CASE_   : List[str]					  =      15
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      -20.0
							SCREAMING_SNAKE_CASE_   : Dict					  =      -4.0

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      processor.batch_decode(
							    snake_case__      ,beam_width=snake_case__      ,beam_prune_logp=snake_case__      ,token_min_logp=snake_case__      ,)
							SCREAMING_SNAKE_CASE_   : str					  =      decoded_processor_out.text

							SCREAMING_SNAKE_CASE_   : int					  =      list(snake_case__ )

							with get_context('fork' ).Pool() as pool:
										SCREAMING_SNAKE_CASE_   : Dict					  =      decoder.decode_beams_batch(
										    snake_case__      ,snake_case__      ,beam_width=snake_case__      ,beam_prune_logp=snake_case__      ,token_min_logp=snake_case__      ,)

							SCREAMING_SNAKE_CASE_   : str					  =      [d[0][0] for d in decoded_decoder_out]
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      [d[0][2] for d in decoded_decoder_out]
							SCREAMING_SNAKE_CASE_   : Tuple					  =      [d[0][3] for d in decoded_decoder_out]

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

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

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






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : int					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : int					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : Dict					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=snake_case__ )

							SCREAMING_SNAKE_CASE_   : int					  =      self._get_dummy_logits()

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      2.0
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      5.0
							SCREAMING_SNAKE_CASE_   : int					  =      -20.0
							SCREAMING_SNAKE_CASE_   : List[str]					  =      True

							SCREAMING_SNAKE_CASE_   : Dict					  =      processor.batch_decode(
							    snake_case__      ,alpha=snake_case__      ,beta=snake_case__      ,unk_score_offset=snake_case__      ,lm_score_boundary=snake_case__      ,)
							SCREAMING_SNAKE_CASE_   : List[str]					  =      decoded_processor_out.text

							SCREAMING_SNAKE_CASE_   : Tuple					  =      list(snake_case__ )
							decoder.reset_params(
							    alpha=snake_case__      ,beta=snake_case__      ,unk_score_offset=snake_case__      ,lm_score_boundary=snake_case__      ,)

							with get_context('fork' ).Pool() as pool:
										SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      decoder.decode_beams_batch(
										    snake_case__      ,snake_case__      ,)

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

							self.assertListEqual(snake_case__      ,snake_case__ )
							self.assertListEqual(['<s> </s> <s> </s> </s>', '</s> </s> <s> </s> </s>']      ,snake_case__ )
							SCREAMING_SNAKE_CASE_   : List[str]					  =      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      ,snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm' )

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

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      os.listdir(snake_case__ )
							SCREAMING_SNAKE_CASE_   : Dict					  =      ['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(snake_case__      ,snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : int					  =      snapshot_download('hf-internal-testing/processor_with_lm' )

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      WavaVecaProcessorWithLM.from_pretrained(snake_case__ )

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

							SCREAMING_SNAKE_CASE_   : Tuple					  =      os.listdir(snake_case__ )
							SCREAMING_SNAKE_CASE_   : int					  =      os.listdir(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(snake_case__      ,snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm' )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm' )

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      floats_list((3, 1000) )

							SCREAMING_SNAKE_CASE_   : Tuple					  =      processor_wavaveca(snake_case__      ,return_tensors='np' )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      processor_auto(snake_case__      ,return_tensors='np' )

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

							SCREAMING_SNAKE_CASE_   : Any					  =      self._get_dummy_logits()

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      processor_wavaveca.batch_decode(snake_case__ )
							SCREAMING_SNAKE_CASE_   : int					  =      processor_auto.batch_decode(snake_case__ )

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






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Tuple					  =      self.get_feature_extractor()
							SCREAMING_SNAKE_CASE_   : Any					  =      self.get_tokenizer()
							SCREAMING_SNAKE_CASE_   : str					  =      self.get_decoder()

							SCREAMING_SNAKE_CASE_   : Any					  =      WavaVecaProcessorWithLM(tokenizer=snake_case__      ,feature_extractor=snake_case__      ,decoder=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 		snake_case	(			snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      [d[key] for d in offsets]
							return retrieved_list






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm' )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self._get_dummy_logits()[0]

							SCREAMING_SNAKE_CASE_   : str					  =      processor.decode(snake_case__      ,output_word_offsets=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(snake_case__      ,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 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm' )
							SCREAMING_SNAKE_CASE_   : str					  =      self._get_dummy_logits()

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      processor.batch_decode(snake_case__      ,output_word_offsets=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(snake_case__      ,snake_case__ ) )

							self.assertListEqual(
							    [' '.join(self.get_from_offsets(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 		snake_case	(			self ):
							import torch

							SCREAMING_SNAKE_CASE_   : List[str]					  =      load_dataset('common_voice'      ,'en'      ,split='train'      ,streaming=snake_case__ )
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      ds.cast_column('audio'      ,datasets.Audio(sampling_rate=16000 ) )
							SCREAMING_SNAKE_CASE_   : str					  =      iter(snake_case__ )
							SCREAMING_SNAKE_CASE_   : Dict					  =      next(snake_case__ )

							SCREAMING_SNAKE_CASE_   : Dict					  =      AutoProcessor.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm' )
							SCREAMING_SNAKE_CASE_   : Dict					  =      WavaVecaForCTC.from_pretrained('patrickvonplaten/wav2vec2-base-100h-with-lm' )

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

							with torch.no_grad():
										SCREAMING_SNAKE_CASE_   : Tuple					  =      model(snake_case__ ).logits.cpu().numpy()

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      processor.decode(logits[0]      ,output_word_offsets=snake_case__ )

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

							SCREAMING_SNAKE_CASE_   : Dict					  =      '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(snake_case__      ,'word' ) )      ,snake_case__ )
							self.assertEqual(' '.join(self.get_from_offsets(snake_case__      ,'word' ) )      ,output.text )

							# output times
							SCREAMING_SNAKE_CASE_   : int					  =      torch.tensor(self.get_from_offsets(snake_case__      ,'start_time' ) )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      torch.tensor(self.get_from_offsets(snake_case__      ,'end_time' ) )

							# fmt: off
							SCREAMING_SNAKE_CASE_   : Dict					  =      torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599] )
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94] )
							# fmt: on

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









def        __UpperCAmelCase						(							lowerCamelCase_ :     str  )       ->  bool:







			"""simple docstring"""





			SCREAMING_SNAKE_CASE_   : Any					  =      0
			for ch in input_str:
						SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      ord(lowerCamelCase_  )
						SCREAMING_SNAKE_CASE_   : Tuple					  =      pow(2  ,							lowerCamelCase_  )

						# If we already turned on bit for current character's unicode
						if bitmap >> ch_unicode & 1 == 1:
									return False
						bitmap |= ch_bit_index_on
			return True


if __name__ == "__main__":
						import doctest

						doctest.testmod()



