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




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= "| <pad> <unk> <s> </s> a b c d e f g h i j k".split()
								_SCREAMING_SNAKE_CASE				= dict(zip(UpperCamelCase					,						range(len(UpperCamelCase      )      )      )      )

								_SCREAMING_SNAKE_CASE				= {
								    "unk_token": "<unk>",
								    "bos_token": "<s>",
								    "eos_token": "</s>",
								}
								_SCREAMING_SNAKE_CASE				= {
								    "feature_size": 1,
								    "padding_value": 0.0,
								    "sampling_rate": 16_000,
								    "return_attention_mask": False,
								    "do_normalize": True,
								}

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

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

								# load decoder from hub
								_SCREAMING_SNAKE_CASE				= "hf-internal-testing/ngram-beam-search-decoder"




		def     lowercase       (				self					,						**UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= self.add_kwargs_tokens_map.copy()
								kwargs.update(UpperCamelCase      )
								return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname					,						**UpperCamelCase      )




		def     lowercase       (				self					,						**UpperCamelCase      ):
								return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname					,						**UpperCamelCase      )




		def     lowercase       (				self					,						**UpperCamelCase      ):
								return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name					,						**UpperCamelCase      )




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




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

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

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

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

								# decoder
								self.assertEqual(processor.decoder._alphabet.labels					,						decoder._alphabet.labels      )
								self.assertEqual(
								    processor.decoder.model_container[decoder._model_key]._unigram_set					,						decoder.model_container[decoder._model_key]._unigram_set					,						)
								self.assertIsInstance(processor.decoder					,						UpperCamelCase      )




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= 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				= 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      ):
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								# add token to trigger raise
								tokenizer.add_tokens(["xx"]      )
								with self.assertRaisesRegex(UpperCamelCase					,						"include"      ):
														WavaVecaProcessorWithLM(
														    tokenizer=UpperCamelCase					,						feature_extractor=self.get_feature_extractor()					,						decoder=self.get_decoder()      )




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

								_SCREAMING_SNAKE_CASE				= floats_list((3, 1_000)      )

								_SCREAMING_SNAKE_CASE				= feature_extractor(UpperCamelCase					,						return_tensors="np"      )
								_SCREAMING_SNAKE_CASE				= processor(UpperCamelCase					,						return_tensors="np"      )

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




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

								_SCREAMING_SNAKE_CASE				= "This is a test string"

								_SCREAMING_SNAKE_CASE				= processor(text=UpperCamelCase      )

								_SCREAMING_SNAKE_CASE				= tokenizer(UpperCamelCase      )

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




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




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

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

								_SCREAMING_SNAKE_CASE				= processor.decode(UpperCamelCase      )

								_SCREAMING_SNAKE_CASE				= decoder.decode_beams(UpperCamelCase      )[0]

								self.assertEqual(decoded_decoder[0]					,						decoded_processor.text      )
								self.assertEqual("</s> <s> </s>"					,						decoded_processor.text      )
								self.assertEqual(decoded_decoder[-2]					,						decoded_processor.logit_score      )
								self.assertEqual(decoded_decoder[-1]					,						decoded_processor.lm_score      )




		@parameterized.expand([[None], ["fork"], ["spawn"]]      )
		def     lowercase       (				self					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

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

								_SCREAMING_SNAKE_CASE				= list(UpperCamelCase      )

								with get_context("fork"      ).Pool() as p:
														_SCREAMING_SNAKE_CASE				= decoder.decode_beams_batch(UpperCamelCase					,						UpperCamelCase      )

								_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= [], [], []
								for beams in decoded_beams:
														texts_decoder.append(beams[0][0]      )
														logit_scores_decoder.append(beams[0][-2]      )
														lm_scores_decoder.append(beams[0][-1]      )

								self.assertListEqual(UpperCamelCase					,						decoded_processor.text      )
								self.assertListEqual(["<s> <s> </s>", "<s> <s> <s>"]					,						decoded_processor.text      )
								self.assertListEqual(UpperCamelCase					,						decoded_processor.logit_score      )
								self.assertListEqual(UpperCamelCase					,						decoded_processor.lm_score      )




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

								_SCREAMING_SNAKE_CASE				= self._get_dummy_logits()

								_SCREAMING_SNAKE_CASE				= 15
								_SCREAMING_SNAKE_CASE				= -20.0
								_SCREAMING_SNAKE_CASE				= -4.0

								_SCREAMING_SNAKE_CASE				= processor.batch_decode(
								    UpperCamelCase					,						beam_width=UpperCamelCase					,						beam_prune_logp=UpperCamelCase					,						token_min_logp=UpperCamelCase					,						)
								_SCREAMING_SNAKE_CASE				= decoded_processor_out.text

								_SCREAMING_SNAKE_CASE				= list(UpperCamelCase      )

								with get_context("fork"      ).Pool() as pool:
														_SCREAMING_SNAKE_CASE				= decoder.decode_beams_batch(
														    UpperCamelCase					,						UpperCamelCase					,						beam_width=UpperCamelCase					,						beam_prune_logp=UpperCamelCase					,						token_min_logp=UpperCamelCase					,						)

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

								self.assertListEqual(UpperCamelCase					,						UpperCamelCase      )
								self.assertListEqual(["</s> <s> <s>", "<s> <s> <s>"]					,						UpperCamelCase      )

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

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




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

								_SCREAMING_SNAKE_CASE				= self._get_dummy_logits()

								_SCREAMING_SNAKE_CASE				= 2.0
								_SCREAMING_SNAKE_CASE				= 5.0
								_SCREAMING_SNAKE_CASE				= -20.0
								_SCREAMING_SNAKE_CASE				= True

								_SCREAMING_SNAKE_CASE				= processor.batch_decode(
								    UpperCamelCase					,						alpha=UpperCamelCase					,						beta=UpperCamelCase					,						unk_score_offset=UpperCamelCase					,						lm_score_boundary=UpperCamelCase					,						)
								_SCREAMING_SNAKE_CASE				= decoded_processor_out.text

								_SCREAMING_SNAKE_CASE				= list(UpperCamelCase      )
								decoder.reset_params(
								    alpha=UpperCamelCase					,						beta=UpperCamelCase					,						unk_score_offset=UpperCamelCase					,						lm_score_boundary=UpperCamelCase					,						)

								with get_context("fork"      ).Pool() as pool:
														_SCREAMING_SNAKE_CASE				= decoder.decode_beams_batch(
														    UpperCamelCase					,						UpperCamelCase					,						)

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

								self.assertListEqual(UpperCamelCase					,						UpperCamelCase      )
								self.assertListEqual(["<s> </s> <s> </s> </s>", "</s> </s> <s> </s> </s>"]					,						UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= processor.decoder.model_container[processor.decoder._model_key]
								self.assertEqual(lm_model.alpha					,						2.0      )
								self.assertEqual(lm_model.beta					,						5.0      )
								self.assertEqual(lm_model.unk_score_offset					,						-20.0      )
								self.assertEqual(lm_model.score_boundary					,						UpperCamelCase      )




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"      )

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

								_SCREAMING_SNAKE_CASE				= os.listdir(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= ["alphabet.json", "language_model"]

								downloaded_decoder_files.sort()
								expected_decoder_files.sort()

								# test that only decoder relevant files from
								# https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
								# are downloaded and none of the rest (e.g. README.md, ...)
								self.assertListEqual(UpperCamelCase					,						UpperCamelCase      )




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= snapshot_download("hf-internal-testing/processor_with_lm"      )

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM.from_pretrained(UpperCamelCase      )

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

								_SCREAMING_SNAKE_CASE				= os.listdir(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= os.listdir(UpperCamelCase      )

								local_decoder_files.sort()
								expected_decoder_files.sort()

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




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"      )
								_SCREAMING_SNAKE_CASE				= AutoProcessor.from_pretrained("hf-internal-testing/processor_with_lm"      )

								_SCREAMING_SNAKE_CASE				= floats_list((3, 1_000)      )

								_SCREAMING_SNAKE_CASE				= processor_wavaveca(UpperCamelCase					,						return_tensors="np"      )
								_SCREAMING_SNAKE_CASE				= processor_auto(UpperCamelCase					,						return_tensors="np"      )

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

								_SCREAMING_SNAKE_CASE				= self._get_dummy_logits()

								_SCREAMING_SNAKE_CASE				= processor_wavaveca.batch_decode(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= processor_auto.batch_decode(UpperCamelCase      )

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




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.get_feature_extractor()
								_SCREAMING_SNAKE_CASE				= self.get_tokenizer()
								_SCREAMING_SNAKE_CASE				= self.get_decoder()

								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM(tokenizer=UpperCamelCase					,						feature_extractor=UpperCamelCase					,						decoder=UpperCamelCase      )

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




		@staticmethod
		def     lowercase       (				UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= [d[key] for d in offsets]
								return retrieved_list




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"      )
								_SCREAMING_SNAKE_CASE				= self._get_dummy_logits()[0]

								_SCREAMING_SNAKE_CASE				= processor.decode(UpperCamelCase					,						output_word_offsets=UpperCamelCase      )
								# check Wav2Vec2CTCTokenizerOutput keys for word
								self.assertEqual(len(outputs.keys()      )					,						4      )
								self.assertTrue("text" in outputs      )
								self.assertTrue("word_offsets" in outputs      )
								self.assertTrue(isinstance(UpperCamelCase					,						UpperCamelCase      )      )

								self.assertEqual(" ".join(self.get_from_offsets(outputs["word_offsets"]					,						"word"      )      )					,						outputs.text      )
								self.assertListEqual(self.get_from_offsets(outputs["word_offsets"]					,						"word"      )					,						["<s>", "<s>", "</s>"]      )
								self.assertListEqual(self.get_from_offsets(outputs["word_offsets"]					,						"start_offset"      )					,						[0, 2, 4]      )
								self.assertListEqual(self.get_from_offsets(outputs["word_offsets"]					,						"end_offset"      )					,						[1, 3, 5]      )




		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"      )
								_SCREAMING_SNAKE_CASE				= self._get_dummy_logits()

								_SCREAMING_SNAKE_CASE				= processor.batch_decode(UpperCamelCase					,						output_word_offsets=UpperCamelCase      )

								# check Wav2Vec2CTCTokenizerOutput keys for word
								self.assertEqual(len(outputs.keys()      )					,						4      )
								self.assertTrue("text" in outputs      )
								self.assertTrue("word_offsets" in outputs      )
								self.assertTrue(isinstance(UpperCamelCase					,						UpperCamelCase      )      )

								self.assertListEqual(
								    [" ".join(self.get_from_offsets(UpperCamelCase					,						"word"      )      ) for o in outputs["word_offsets"]]					,						outputs.text      )
								self.assertListEqual(self.get_from_offsets(outputs["word_offsets"][0]					,						"word"      )					,						["<s>", "<s>", "</s>"]      )
								self.assertListEqual(self.get_from_offsets(outputs["word_offsets"][0]					,						"start_offset"      )					,						[0, 2, 4]      )
								self.assertListEqual(self.get_from_offsets(outputs["word_offsets"][0]					,						"end_offset"      )					,						[1, 3, 5]      )




		@slow
		@require_torch
		@require_torchaudio
		def     lowercase       (				self      ):
								import torch

								_SCREAMING_SNAKE_CASE				= load_dataset("common_voice"					,						"en"					,						split="train"					,						streaming=UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= ds.cast_column("audio"					,						datasets.Audio(sampling_rate=16_000      )      )
								_SCREAMING_SNAKE_CASE				= iter(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= next(UpperCamelCase      )

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

								with torch.no_grad():
														_SCREAMING_SNAKE_CASE				= model(UpperCamelCase      ).logits.cpu().numpy()

								_SCREAMING_SNAKE_CASE				= processor.decode(logits[0]					,						output_word_offsets=UpperCamelCase      )

								_SCREAMING_SNAKE_CASE				= model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
								_SCREAMING_SNAKE_CASE				= [
								    {
								        "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				= "WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL"

								# output words
								self.assertEqual(" ".join(self.get_from_offsets(UpperCamelCase					,						"word"      )      )					,						UpperCamelCase      )
								self.assertEqual(" ".join(self.get_from_offsets(UpperCamelCase					,						"word"      )      )					,						output.text      )

								# output times
								_SCREAMING_SNAKE_CASE				= torch.tensor(self.get_from_offsets(UpperCamelCase					,						"start_time"      )      )
								_SCREAMING_SNAKE_CASE				= torch.tensor(self.get_from_offsets(UpperCamelCase					,						"end_time"      )      )

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

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

'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_snake_case				:   Optional[Any]     =				{
    """configuration_rag""": ["""RagConfig"""],
    """retrieval_rag""": ["""RagRetriever"""],
    """tokenization_rag""": ["""RagTokenizer"""],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_snake_case				:   int     =				[
						    """RagModel""",
						    """RagPreTrainedModel""",
						    """RagSequenceForGeneration""",
						    """RagTokenForGeneration""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_snake_case				:   Dict     =				[
						    """TFRagModel""",
						    """TFRagPreTrainedModel""",
						    """TFRagSequenceForGeneration""",
						    """TFRagTokenForGeneration""",
						]


if TYPE_CHECKING:
						from .configuration_rag import RagConfig
						from .retrieval_rag import RagRetriever
						from .tokenization_rag import RagTokenizer

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_rag import RagModel, RagPreTrainedModel, RagSequenceForGeneration, RagTokenForGeneration

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_rag import (
												    TFRagModel,
												    TFRagPreTrainedModel,
												    TFRagSequenceForGeneration,
												    TFRagTokenForGeneration,
												)

else:
						import sys

						_snake_case				:   str     =				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)