


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





    """simple docstring"""






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

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

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







    def  lowercase_							(				self     ,	**SCREAMING_SNAKE_CASE_      )							->	Optional[Any]:
         __lowerCamelCase  :      Dict														=						self.add_kwargs_tokens_map.copy()
         kwargs.update(SCREAMING_SNAKE_CASE_      )
         return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname     ,	**SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self     ,	**SCREAMING_SNAKE_CASE_      )							->	str:
         return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname     ,	**SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self     ,	**SCREAMING_SNAKE_CASE_      )							->	str:
         return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name     ,	**SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	Optional[int]:
         shutil.rmtree(self.tmpdirname      )







    def  lowercase_							(				self      )							->	Union[str, Any]:
         __lowerCamelCase  :      str														=						self.get_tokenizer()
         __lowerCamelCase  :      Dict														=						self.get_feature_extractor()
         __lowerCamelCase  :      List[Any]														=						self.get_decoder()

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

         processor.save_pretrained(self.tmpdirname      )
         __lowerCamelCase  :      Optional[int]														=						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  lowercase_							(				self      )							->	Optional[Any]:
         __lowerCamelCase  :      Union[str, 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
         __lowerCamelCase  :      Dict														=						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  lowercase_							(				self      )							->	int:
         __lowerCamelCase  :      Optional[Any]														=						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  lowercase_							(				self      )							->	int:
         __lowerCamelCase  :      Dict														=						self.get_feature_extractor()
         __lowerCamelCase  :      Any														=						self.get_tokenizer()
         __lowerCamelCase  :      Any														=						self.get_decoder()

         __lowerCamelCase  :      Optional[int]														=						WavaVecaProcessorWithLM(tokenizer=SCREAMING_SNAKE_CASE_     ,	feature_extractor=SCREAMING_SNAKE_CASE_     ,	decoder=SCREAMING_SNAKE_CASE_      )

         __lowerCamelCase  :      Dict														=						floats_list((3, 10_00)      )

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

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

         __lowerCamelCase  :      int														=						'This is a test string'

         __lowerCamelCase  :      Any														=						processor(text=SCREAMING_SNAKE_CASE_      )

         __lowerCamelCase  :      List[Any]														=						tokenizer(SCREAMING_SNAKE_CASE_      )

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







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_=(2, 10, 16)     ,	SCREAMING_SNAKE_CASE_=77      )							->	List[Any]:
         np.random.seed(SCREAMING_SNAKE_CASE_      )
         return np.random.rand(*SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self      )							->	List[str]:
         __lowerCamelCase  :      str														=						self.get_feature_extractor()
         __lowerCamelCase  :      Union[str, Any]														=						self.get_tokenizer()
         __lowerCamelCase  :      Optional[Any]														=						self.get_decoder()

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

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

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

         __lowerCamelCase  :      List[str]														=						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  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	str:
         __lowerCamelCase  :      Optional[int]														=						self.get_feature_extractor()
         __lowerCamelCase  :      Any														=						self.get_tokenizer()
         __lowerCamelCase  :      List[Any]														=						self.get_decoder()

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

         __lowerCamelCase  :      Optional[Any]														=						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  :      List[str]														=						processor.batch_decode(SCREAMING_SNAKE_CASE_      )
         else:
              with get_context(SCREAMING_SNAKE_CASE_      ).Pool() as pool:
                   __lowerCamelCase  :      str														=						processor.batch_decode(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )

         __lowerCamelCase  :      Optional[int]														=						list(SCREAMING_SNAKE_CASE_      )

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

         __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase  :      List[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(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  lowercase_							(				self      )							->	Optional[Any]:
         __lowerCamelCase  :      str														=						self.get_feature_extractor()
         __lowerCamelCase  :      str														=						self.get_tokenizer()
         __lowerCamelCase  :      Any														=						self.get_decoder()

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

         __lowerCamelCase  :      Any														=						self._get_dummy_logits()

         __lowerCamelCase  :      int														=						15
         __lowerCamelCase  :      Dict														=						-2_0.0
         __lowerCamelCase  :      Optional[Any]														=						-4.0

         __lowerCamelCase  :      List[Any]														=						processor.batch_decode(
             SCREAMING_SNAKE_CASE_     ,	beam_width=SCREAMING_SNAKE_CASE_     ,	beam_prune_logp=SCREAMING_SNAKE_CASE_     ,	token_min_logp=SCREAMING_SNAKE_CASE_     ,	)
         __lowerCamelCase  :      List[Any]														=						decoded_processor_out.text

         __lowerCamelCase  :      Optional[int]														=						list(SCREAMING_SNAKE_CASE_      )

         with get_context('fork'      ).Pool() as pool:
              __lowerCamelCase  :      List[Any]														=						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  :      Union[str, Any]														=						[d[0][0] for d in decoded_decoder_out]
         __lowerCamelCase  :      Tuple														=						[d[0][2] for d in decoded_decoder_out]
         __lowerCamelCase  :      List[Any]														=						[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  lowercase_							(				self      )							->	List[Any]:
         __lowerCamelCase  :      List[Any]														=						self.get_feature_extractor()
         __lowerCamelCase  :      int														=						self.get_tokenizer()
         __lowerCamelCase  :      int														=						self.get_decoder()

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

         __lowerCamelCase  :      Dict														=						self._get_dummy_logits()

         __lowerCamelCase  :      Union[str, Any]														=						2.0
         __lowerCamelCase  :      str														=						5.0
         __lowerCamelCase  :      int														=						-2_0.0
         __lowerCamelCase  :      Optional[Any]														=						True

         __lowerCamelCase  :      str														=						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  :      Any														=						decoded_processor_out.text

         __lowerCamelCase  :      int														=						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  :      Union[str, Any]														=						decoder.decode_beams_batch(
                  SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	)

         __lowerCamelCase  :      Tuple														=						[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  :      Union[str, Any]														=						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  lowercase_							(				self      )							->	Optional[int]:
         __lowerCamelCase  :      Any														=						WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )

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

         __lowerCamelCase  :      Optional[int]														=						os.listdir(SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Union[str, Any]														=						['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  lowercase_							(				self      )							->	List[str]:
         __lowerCamelCase  :      Union[str, Any]														=						snapshot_download('hf-internal-testing/processor_with_lm'      )

         __lowerCamelCase  :      Optional[Any]														=						WavaVecaProcessorWithLM.from_pretrained(SCREAMING_SNAKE_CASE_      )

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

         __lowerCamelCase  :      str														=						os.listdir(SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Dict														=						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  lowercase_							(				self      )							->	str:
         __lowerCamelCase  :      Optional[int]														=						WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
         __lowerCamelCase  :      Dict														=						AutoProcessor.from_pretrained('hf-internal-testing/processor_with_lm'      )

         __lowerCamelCase  :      Tuple														=						floats_list((3, 10_00)      )

         __lowerCamelCase  :      Optional[Any]														=						processor_wavaveca(SCREAMING_SNAKE_CASE_     ,	return_tensors='np'      )
         __lowerCamelCase  :      Optional[int]														=						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  :      int														=						self._get_dummy_logits()

         __lowerCamelCase  :      Tuple														=						processor_wavaveca.batch_decode(SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Optional[Any]														=						processor_auto.batch_decode(SCREAMING_SNAKE_CASE_      )

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







    def  lowercase_							(				self      )							->	int:
         __lowerCamelCase  :      Optional[int]														=						self.get_feature_extractor()
         __lowerCamelCase  :      List[str]														=						self.get_tokenizer()
         __lowerCamelCase  :      List[Any]														=						self.get_decoder()

         __lowerCamelCase  :      Union[str, Any]														=						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  lowercase_							(				SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )							->	Union[str, Any]:
         __lowerCamelCase  :      int														=						[d[key] for d in offsets]
         return retrieved_list







    def  lowercase_							(				self      )							->	Tuple:
         __lowerCamelCase  :      str														=						WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
         __lowerCamelCase  :      Optional[Any]														=						self._get_dummy_logits()[0]

         __lowerCamelCase  :      Dict														=						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  lowercase_							(				self      )							->	int:
         __lowerCamelCase  :      Tuple														=						WavaVecaProcessorWithLM.from_pretrained('hf-internal-testing/processor_with_lm'      )
         __lowerCamelCase  :      Union[str, Any]														=						self._get_dummy_logits()

         __lowerCamelCase  :      Tuple														=						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  lowercase_							(				self      )							->	Union[str, Any]:
         import torch

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

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

         with torch.no_grad():
              __lowerCamelCase  :      Optional[int]														=						model(SCREAMING_SNAKE_CASE_      ).logits.cpu().numpy()

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

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

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

         # output times
         __lowerCamelCase  :      str														=						torch.tensor(self.get_from_offsets(SCREAMING_SNAKE_CASE_     ,	'start_time'      )      )
         __lowerCamelCase  :      Tuple														=						torch.tensor(self.get_from_offsets(SCREAMING_SNAKE_CASE_     ,	'end_time'      )      )

         # fmt: off
         __lowerCamelCase  :      Any														=						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  :      str														=						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 typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


A		=						{'configuration_vit': ['VIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ViTConfig', 'ViTOnnxConfig']}

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A		=						['ViTFeatureExtractor']
			A		=						['ViTImageProcessor']

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A		=						[
			    'VIT_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'ViTForImageClassification',
			    'ViTForMaskedImageModeling',
			    'ViTModel',
			    'ViTPreTrainedModel',
			]

try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A		=						[
			    'TFViTForImageClassification',
			    'TFViTModel',
			    'TFViTPreTrainedModel',
			]

try:
			if not is_flax_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A		=						[
			    'FlaxViTForImageClassification',
			    'FlaxViTModel',
			    'FlaxViTPreTrainedModel',
			]

if TYPE_CHECKING:
			from .configuration_vit import VIT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViTConfig, ViTOnnxConfig

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .feature_extraction_vit import ViTFeatureExtractor
						from .image_processing_vit import ViTImageProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_vit import (
						    VIT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    ViTForImageClassification,
						    ViTForMaskedImageModeling,
						    ViTModel,
						    ViTPreTrainedModel,
						)

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_vit import TFViTForImageClassification, TFViTModel, TFViTPreTrainedModel

			try:
						if not is_flax_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_flax_vit import FlaxViTForImageClassification, FlaxViTModel, FlaxViTPreTrainedModel


else:
			import sys

			A		=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



